JPH11328134A - Data transmission / reception method between computers - Google Patents

Abstract

(57) [Summary] A message passing type stream communication can be used from a TCP / IP application program. An emulation library provided in each computer is provided with an application program.
It determines whether the communication partner process specified by the communication request from is inside or outside the parallel computer 101, and if it is inside, starts the high-speed communication library 135 and passes the message through the high-speed internal communication network 105. Data is transmitted and received by the mobile communication system. This data transmission and reception
It is executed to realize stream communication. When the destination is the external computer 104 of the parallel computer 101,
The library 112 is a TCP / IP processing routine 11
4 requests communication according to TCP / IP.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a method for transmitting and receiving data between computers in a computer system having a plurality of computers connected by a plurality of types of communication networks, and more particularly to a method for executing message passing communication. Suitable,
The present invention relates to a method for transmitting and receiving data between computers.

[0002]

2. Description of the Related Art TCP / IP is a protocol for communication between computers.
Are very commonly used. A program configured to communicate with another program using TCP / IP is hereinafter referred to as a TCP / IP application program. There is also a computer system in which a communication protocol other than TCP / IP can be used from the TCP / IP application program. That is, the computers constituting the computer system are configured by a plurality of networks having different performances, and when a computer in the system communicates with another computer, the computer uses any of these networks for the communication. Depending on
Systems using TCP / IP or other communication protocols have also been proposed. For example, Steven H. Rod at Berkeley
The system developed by rigues et al. consists of a wide area network that can be used with the TCP / IP protocol, and a local network that uses a simpler, lower-overhead protocol in a smaller area and connects to the local network. Computers communicated using this protocol, and computers connected to the wide area network
Communication is performed according to the TCP / IP protocol. For example, "High-
Performance Local-Area Communication With Fast Soc
ket ", USENIX '97 Annual Technical Conference pp.25
7-274).

The computer system is provided with a TCP / IP emulation library so that the TCP / IP application program can use the communication protocol. In the above system, this T
The CP / IP emulation library is called a fast socket (Fast Socket).

The high-speed socket uses an active message developed for a workstation cluster as a simple communication protocol. For example, references T. von Eicken, DE Culler, SC
Goldstein, KE Schauser "Active Messages: a Mec
hanism for Integrated Communication and Computatio
n ", in Proceedings of the 19th International Sympo
sium on Computer Architecture, May 1992 pp.256-266
reference. In the active message, the application program on the data transmitting side interrupts the application program on the receiving side, and the receiving side exchanges data in such a manner that the receiving side performs data reception processing triggered by the interruption.

[0005] A parallel computer is a computer that aims to solve one problem in cooperation with a plurality of computers while communicating with each other. In order to satisfy this purpose, generally, the computers inside the parallel computers are interconnected by a high-speed internal high-speed communication network, and at least some of the computers in the parallel computers are further connected to an external network by a broader network such as a LAN. Connected to a calculator.

The communication protocol used for a wide area network is mainly TCP / IP. In order to use the internal high-speed communication network, the parallel computers use high-speed communication hardware for communicating with other internal computers via the internal high-speed communication network, and a high-speed communication library for using the hardware. Is provided. At present, the communication protocol adopted by many parallel computers is message-passing type communication. The message passing type communication is communication in which communication is performed when a transmission command issued by a transmission application program and a reception command issued by a reception application program are associated one-to-one. In many cases, this communication scheme is suitable for high-speed communication hardware inside a parallel computer. As a high-speed communication library used to realize the message passing type communication, a library called a remote memory writing library or a PUT library is mainly used.

[0007] The communication overhead inside the parallel computer is:
Significant reduction can be achieved by using high speed communication hardware. In the interrupt-type communication system used for the active message, the overhead of the interrupt becomes conspicuous. However, the message passing communication method does not require an interrupt, and is therefore more suitable for communication inside a parallel computer than active message communication.

[0008]

As described above, the communication protocol for using the internal high-speed communication network of the parallel computer is generally of a message passing type. However, many business application programs used when a parallel computer is used in the business field are mostly TCP / IP.
It is configured to use conventions. Therefore, such an application program cannot directly use the message passing communication system as it is. In addition, there is no known method for realizing stream communication using a message passing communication system. Further, the method of realizing the stream communication used in the active message type communication using the interrupt cannot be directly used for the stream communication in the message passing type communication.

Accordingly, an object of the present invention is to provide an inter-computer data transmission / reception method which enables stream communication between a plurality of application programs operating on a computer configured to execute message passing communication. It is.

A more specific object of the present invention is to provide a plurality of communication apparatuses configured to execute communication via a first computer network using a communication protocol different from that of message passing communication such as TCP / IP. The present invention provides an inter-computer data transmission / reception method that enables a message-passing communication to be executed between application programs using a communication network faster than the computer network.

Still another object of the present invention is to operate on a computer connected to a first communication network and a second communication network which is faster than the first communication network.
For example, an application program configured to communicate on the basis of a first communication protocol such as a TCP / IP communication protocol is connected to another application program operating on another computer connected to the first communication network. Between,
It is possible to execute communication based on the communication protocol, and to use the second communication network with another application program running on another computer connected to the second communication network. An object of the present invention is to provide an inter-computer data transmission / reception method capable of performing high-speed communication.

Still another object of the present invention is to provide an inter-computer data transmission / reception method in which communication using the second communication network can be message-passing type communication.

[0013]

In order to achieve the above object, a method for transmitting and receiving data between computers according to the present invention comprises the following steps.
Each of the plurality of transmission data specified by the plurality of transmission instructions issued by the first application program executed on the second computer is issued by the second application program executed on the second computer. In response to a plurality of reception commands, the reception is performed by message passing type communication. This reception is controlled by an emulation library provided on the second computer.

[0014] Further, a plurality of buffers, each of which is obtained by dividing a portion obtained by dividing into a size portion specified by the plurality of reception commands, out of the concatenated data formed by the concatenation of the plurality of transmission data, with each reception command. Each of the received transmission data is processed so as to realize the stream communication of storing the transmission data. This processing is controlled by the emulation library.

More specifically, the inter-computer data transmission / reception method according to the present invention executes the following processing.

(A) The length of data to be transmitted by the transmission application in one transmission command is detected by the reception emulation library, and (b) the transmission data length is detected by the application once. The data reception length specified by the instruction is compared with the reception side emulation library. (C) In the above comparison, if the transmission data length is longer than the data reception length,
The receiving-side emulation library receives all of the data in the buffer area once secured in memory, copies the data for the data reception length specified by the application from there to the application area, and sets the transmission data length to the data reception length. In the following cases, the receiving emulation library directly receives the data in the application area.

(D) When data is left in the buffer area when the application issues the reception command, the data is copied from there to the application area.

More specifically, a TCP / IP emulation library is prepared to realize the data transmission / reception method according to the present invention. This library is
It has the same interface as the CP / IP socket application program interface. If the communication partner is outside the parallel computer, the conventional system call is executed.
If it is inside, it is decided to use a high-speed communication network based on a message passing communication system for parallel computers such as MPI. That is, the TCP / IP emulation library has the following features.

(1) When communicating within a parallel computer,
A stream communication service equivalent to TCP / IP is provided using a communication procedure suitable for a message passing communication system.

(2) The communication method is separated using an appropriate means as a TCP / IP emulation library.

(3) Data of external communication and data of internal communication are detected by a spin loop. Alternatively, data of external communication and data of internal communication are detected by separate threads.

[0022]

DESCRIPTION OF THE PREFERRED EMBODIMENTS <Prior Art and Problems> Prior to describing an embodiment of the present invention, a conventional technique and its problems will be described.

(1) TCP / IP FIG. 13 shows the hierarchy of TCP / IP. In TCP / IP, a link layer 301, an IP layer 302, a TCP layer 3
03, four layers of the application layer 306 are defined. Actually, a physical layer exists below the link layer 301, but this layer is not described for simplicity. In the following, for simplicity, layers 303 and 30 below the application layer will be described.
TCP / IP combining layer group 304 consisting of 2,301
Called layer. Generally, a program (hereinafter, referred to as a TCP / IP processing routine) necessary for performing communication according to a procedure determined by TCP / IP is included in the OS. To execute communication according to the procedure defined by TCP / IP, the TCP / IP layer 304
The specific processing is respectively performed by each of the plurality of layers constituting. In this specification, a plurality of processes respectively executed by these layers or a plurality of program routines for executing the processes are collectively referred to as a TCP / IP processing routine.

The application program is TCP / I
As an interface for utilizing the P processing routine, a socket application programming interface (socket API) 111 is generally used.
In order for the application program to use the TCP / IP processing routine, a system call group called a socket library is provided as a part of the OS.

In this specification, calling a system call and a function for data reception or calling a system call and a function for data transmission is to issue a reception command or a transmission command in combination with each function. Sometimes. The socket application program interface is defined as an application program interface of a socket library. An application program (hereinafter, referred to as TCP / IP) that performs communication using TCP / IP described according to a socket application program interface.
An example of the application program will be described below.

(Server side) (client side) sa = socket (AF_INET, SOCK_STREAM, 0); sb0 = socket (AF_INET, SOCK_STREAM, 0); bind (sa, server, slen); listen (sa, 5); sa1 = accept (sa, & client, &clen); connect (sb0, server, slen); read (sa1, buffer1, length1); write (sb0, buffer0, length0); read (sa1, buffer2, length2); write (sb0, buffer3, length3); ・ ・ ・ ・ ・ ・ close (sa1); close (sa); close (sb0);
Application program and client-side T
The CP / IP application program calls a system call socket (socket) included in a TCP / IP processing routine provided in the computer on which the CP / IP application program is running. The called system call socket creates an object called a socket, which acts as a communication end, and returns a socket descriptor. In the above example, the server-side and client-side TCP / IP application programs receive the returned socket descriptors as sa or sb0, respectively.

The socket descriptor is a socket identifier (ID) uniquely determined for each socket in the application program, and is composed of an integer value. All operations on the created socket are performed by specifying this socket descriptor. In the following description, unless otherwise specified, the socket and the socket descriptor are synonymous. The argument AF_INET of the above system call represents the address family Internet, and indicates that the socket is used for communication via the Internet. In addition, the argument SOCK_STREA
M requests stream communication. The last argument is the one that specifies the protocol. When this value is zero, the protocol is determined by the two arguments preceding that argument.
In this case, the TCP / IP protocol will be used. After the socket is created, the TCP / IP application programs on the server side and the client side perform socket connection processing in different procedures.

The server calls a system call bind included in the TCP / IP processing routine. The called system call bind associates the socket sa specified by the argument with the name specified by the argument. The name is composed of a combination of an IP address and a port number. In the above example, the socket identifier sa is associated with the name composed of the pair of the IP address and the port number stored in the structure server having the size specified by slen. The server further calls a system call listen included in the TCP / IP processing routine.

This system call listen sets the socket sa specified by the argument as a socket for receiving a connection request. The second argument of this system call represents the size to request from the queue used to temporarily hold the connection request and other connection requests, in this case the call Requesting a queue that can hold.

As a result of the above processing, a communication path is logically determined between the server side and the client side.

Then, the server side accepts a system call (accept) included in the TCP / IP processing routine.
pt). This system call puts the socket sa specified by the argument in a waiting state for a connection request.
The second and third arguments of this system call indicate the IP address and length of the client that issued the connection request to be waited for.

On the other hand, the client side transmits a system call connect (conn) included in the TCP / IP processing routine.
Nect). This system call returns the name specified by the argument, in this case the server side socket sa.
Name (stored in the structure server)
IP address sin_addr and port number sin_p
(or combination of ort) is connected to the socket sb0 specified by the argument.

Further, in the server-side computer, the previously called system call accept receives the connection request, and sets the socket sa1 specified by the above-mentioned argument for the system call accept for communication with the client side. Create a new socket. Thus,
This means that a communication path has been established between the server-side socket sa1 and the client-side socket sb0.

When the client sends data to the server with the connection between the sockets established, the client calls a system call write included in the TCP / IP processing routine. The arguments to this system call specify the address buffer0 of the buffer used to hold the data to be transmitted and the length length0 of the buffer. The system call write transmits the data in the buffer using the socket sb0 specified by the system call. The server calls a system call read included in the TCP / IP processing routine. This system call receives the data transferred via the socket sa1 specified by the argument and writes the data into the buffer at the address buffer1 specified by the argument. Thus, data is transferred between the two application programs. If necessary, the client calls multiple write system calls to send multiple subsequent data, respectively, and the server calls one or more read system calls to receive the subsequent data. .

The socket descriptor is defined as a type of file descriptor used when performing input / output to a file or standard input / output. For this reason, in the socket application program interface, through the same interface as when inputting and outputting files etc.,
Data can be transmitted and received.

When the communication between the server side and the client side programs is completed, the server side calls a system call close to close the socket sa1 specified by the argument. The server side calls the same system call close again, and this closes the socket sa this time. The client side similarly calls a system call close, and this system call closes the socket sb0.

(2) Switching of communication method in high-speed socket In the conventional TCP / IP, a name (serv
er) is associated with the socket (sa). At this time, in the high-speed socket, a socket dedicated to high-speed communication is generated as follows. First, the port number (the port number si stored in the structure server) of the name specified when the application calls the system call bind
n_port) is subjected to a hash function to derive a new shadow port number. Next, a shadow socket is newly generated by calling a system call socket.
Finally, call the bind system call to associate the shadow port number with the shadow socket. When performing high-speed communication, the server and client
When calling and connecting pt and connect, a communication path dedicated to high-speed communication is attached by using the shadow socket.

In this method, special processing is required when a system call bind or a system call listen is called.

(3) Stream Communication by TCP / IP Processing Routine The TCP / IP socket library services stream communication. Stream communication refers to one or a plurality of read systems in which a plurality of data sent by a transmitting application program by a series of write system calls are processed as a continuous data stream, and the data stream is issued by a receiving application program. This is a communication method in which one or more pieces of data having an arbitrary length designated by a call are divided and received.

The operation of the conventional stream communication will be described with reference to FIG. Here, an example is shown in which the transmission application program 801 sends data to the reception application program 802. The transmission application program 801 first calls the first write system call and transmits 50 kilobytes (KB) of data in the buffer 803 of the program (805). In FIG. 14, the unit KB is omitted for simplification. The TCP / IP processing routine on the transmission side
The transmission data in 03 is temporarily copied to a buffer (not shown) secured in the OS, divided into a plurality of packets, and transmitted to the receiving OS. The size of a normal packet is 40 to 1500 bytes. The receiving OS receives the packets in a plurality of buffers (not shown) secured in the OS, connects the packets in a list, and reconfigures the data stream. The transmission application program 801 further issues a second write system call to send another buffer 804 of the program.
The data of 80 KB is transmitted (806). At this time, the TCP / IP processing routine on the transmission side and the TCP
The / IP processing routine operates in the same manner, and combines this data with the previously transmitted data and stores it as one data stream in the aforementioned buffer in the OS.

In the figure, reference numeral 809 schematically shows this data stream held in the OS 900. The first data 807 and the subsequent data 808 are the first data and the second data 808, respectively.
The data represents 50 KB and 80 KB, respectively, transmitted by the second write system call. In stream communication, the receiving application program converts these data into one continuous 130 KB data stream 80.
Catch as 9. Transmission application program 80
The data in the buffers 803 and 804 in the
0, a data portion 807 in a data stream 809,
809 respectively. For this purpose, the reception application program 802 issues a first read system call and sets the 50 KB in the stream data 809.
Of the leading data 807 of the receiving application program 802 in the 30 KB buffer 812 of the receiving application program 802 (814). TCP / I on the receiving side
The P processing routine copies the leading 30 KB data 810 from the data stream 809 to the buffer 812 in response to the read system call. When the receiving application program 802 further issues the second read system call, the remaining 100 KB data 811 in the stream data 809 is copied to the buffer 813 specified by the system call according to the length specified by the system call. (815).

(4) Stream communication in active message type communication In the system using the high-speed socket, stream communication is realized while employing active message type communication. That is, in this system, when a transmission request is issued from a transmission-side application program, the transmission request is executed without waiting for a reception request to be issued from a reception-side application program. The transmission request generates an interrupt on the receiving computer,
This interrupt activates the interrupt handler, and the transmission data is temporarily received in a buffer in the interrupt handler. When the receiving-side application program issues a receiving request, the interrupt handler transfers, to the buffer of the receiving-side application program, data of a size required by the receiving request among the data already received. If the size requested by the application program on the receiving side is smaller than the size of the received data, the processing of the receiving request ends. The remaining data held in the interrupt handler is transferred to the buffer of the receiving application program when a new receiving request is issued from the receiving application program.

Conversely, if the size requested by the receiving-side application program is larger than the size of the received data, the interrupt handler replaces the data when the transmitting-side application program subsequently transmits the data. Supply to the receiving application program. Similarly, when a receiving request is issued from a receiving application program before the transmitting application program issues a sending request, the receiving interrupt handler also executes a subsequent sending application program. When the data is subsequently transmitted, the subsequent data is supplied to the application program on the receiving side. If this subsequent data is larger than the size of the missing data required by the first receive request or the size of the data required by the subsequent receive request, the interrupt handler will reduce the amount of data to the subsequent receive request. Hold for.

Thus, a plurality of data transmitted by a plurality of transmission requests issued by the transmitting application program are supplied to the receiving application program in response to a series of receiving requests issued by the receiving application program. . Thus, in this method,
Stream communication is realized by temporarily storing transmission data in a buffer in the interrupt handler.

However, in a message passing type communication that does not use an interrupt, stream communication cannot be realized using such a method.

Hereinafter, a method for transmitting and receiving data between computers according to the present invention will be described in more detail with reference to some embodiments shown in the drawings. In the following, the same reference numerals represent the same or similar ones. Further, in the second and subsequent embodiments of the invention, only the differences from the first embodiment of the invention will be mainly described.

<First Embodiment of the Invention> (1) Outline of Apparatus FIG. 1 shows an example of a computer system for executing an inter-computer transmission / reception method according to the present invention. In the figure, two computers 102 and 103 inside a parallel computer 101 and 1
It is assumed that two external computers 104 are connected to each other via a communication network. Actually, the number of computers inside and outside the parallel computer 101 is arbitrary. The internal computers 102 and 103 are connected by an internal high-speed communication network 105, and the internal computers 102 and 103 have network interface hardware 119 and 120 dedicated to the internal high-speed communication network 105, respectively. Internal high-speed communication network 1
Reference numeral 05 denotes a network capable of transferring a plurality of packets in parallel with each other at high speed, such as a hyper crossbar switch. Also, the internal computers 102, 1
03 and the external computer 104 are connected to a global communication network 106, and each computer has a communication network 1
06 network interface hardware 1
21, 122, and 123 exist.

Data transmission and reception are performed by the memory 12 of each computer.
The processing is performed between the application programs 107, 108, and 109 that are loaded in the application programs 4, 125, and 126.
In addition, OSs 127, 128, and 129 are loaded in each memory in addition to the application programs, and each OS has a TCP / IP processing routine 114,
There are 115 and 110. In order to execute communication according to the procedure defined by TCP / IP, each layer constituting the TCP / IP layer 304 executes a process. TCP / IP
The processing routine is a collective term of a plurality of processes executed by these layers in order to execute communication according to a procedure defined by TCP / IP.
115 and 110 themselves are the same as those known in the art, and include a plurality of functions that can be called by system calls as described above. TCP / IP processing routine 114, 1
15 and 110 perform communication by network interface hardware 121, 122 and 123 dedicated to the global communication network 106 for the purpose of wide area communication.

Further, the TCP / IP emulation library 112, the message passing type library 140, and the high-speed communication library 135 are loaded in the memory 124 of the computer 102. Similarly, the calculator 10
In the third memory 125, a TCP / IP emulation library 113, a message passing type library 141, and a high-speed communication library 136 are loaded.

The high-speed communication libraries 135 and 136 on the computers 102 and 103 are used for communication by the network interface hardware 119 and 120 dedicated to the internal high-speed communication network 105 for the purpose of high-speed communication inside the parallel computer 101. A library called a remote memory writing library or a PUT library is often used. In this embodiment, the PUT library is used for the high-speed communication libraries 135 and 136. However, the invention is not limited to this library;
A library called an ET library can also be used.

Generally, communication through the high-speed internal communication network 105 is much faster than communication through the global communication network 106. Therefore, the TCP / IP emulation libraries 112 and 113 transmit TCP / IP processing routines 114 and 11 when application programs on the internal computer attempt to perform TCP / IP communication.
5, message passing type library 140,
141, the high-speed communication libraries 135 and 136, and the internal high-speed communication network 105 are used to realize message-passing-type communication, thereby speeding up communication.

Message passing type library 14
Reference numerals 0 and 141 are libraries for activating the high-speed communication library 135 or 136 in response to a request from the TCP / IP emulation library 112 or 113. Message passing type library 14
Reference numerals 0 and 141 are libraries having a message passing type interface to an application program (in this embodiment, TCP / IP emulation libraries 112 and 113).

The TCP / IP emulation libraries 112 and 113 further realize stream communication in this message-passing type communication as provided by the conventional TCP / IP processing routine, thereby increasing the speed of communication. Plan. Since the TCP / IP processing routines 114 and 115 are the functions of the OS 127 and 128, a context switch overhead is always generated when the application program uses them in the related art. However, in the present embodiment, the high-speed communication is performed in the present embodiment. Since the libraries 135 and 136 are used, the overhead can be avoided because the OS does not go through the OS, so that further higher communication speed can be expected.

(2) Logical Configuration and Interface Between Components 1
FIG. 2B is a diagram expressing the above hardware configuration as a logical configuration. In this figure, all parts that are not relevant to the following description are omitted. In addition, the high-speed communication library 13
5,136 and hardware 119,1 dedicated to internal high-speed communication
20 are collectively expressed as high-speed communication mechanisms 116 and 117. Furthermore, the interfaces 111 and 118 between the components are newly shown. Computer 10
The squares representing 2, 103, 104 and the parallel computer 101 respectively indicate that the logical components therein are executed on one computer or the parallel computer 101.

On the computer 104, as in the conventional case, the application program 109 is composed of the TCP / IP 110 and the socket application program interface 111.
It is linked by. Application program 1 running on computers 102 and 103 inside parallel computer 101
07 and 108 are linked to the TCP / IP emulation libraries 112 and 113 by the socket application program interface 111.
Also, TCP / IP emulation library 11
2 and 113 are linked to conventional TCP / IP processing routines 114 and 115, which are functions of the OS, by a socket application program interface 111,
At the same time, it is linked to the high-speed communication mechanisms 116 and 117 by the interface 118 of the MPI specification.

(3) Application program 10
7, 108 In the present embodiment, an application program running on one of the computers 102 in the parallel computer 101, for example, 107 communicates with another application program running on any of the other computers. If
The other application program is a parallel computer 1
01 and the application program running on the computer 104 outside the parallel computer 101, such as 109, the high-speed communication mechanism 116 and the TCP.
/ IP processing routine 114 is properly used. Parallel computer 1
01, two application programs 107, 108 operating on different computers 102, 103 communicate with each other using the high-speed communication mechanisms 116, 117 in order to actually transmit and receive data between the application programs. Not only when, but also when connecting the sockets for the respective application programs to each other, it is necessary to perform special processing so as to use the high-speed communication mechanisms 116 and 117. The TCP / IP emulation library 112 or 113 contains a number of functions for performing this special processing. In the present embodiment, the TCP / IP emulation library 112,
The name of the function provided in 113 is prefixed with EMU_ to distinguish it from the name of the function provided in TCP / IP processing routine 114, 115 or 110.

More specifically, of the application programs 107 or 108 operating on the computers 102 and 103 in the parallel computer 101, the application programs operating on the server side and the client side execute the following programs, respectively. Is generated.

(Server side) (client side) sa = socket (AF_INET, SOCK_STREAM, 0); sb0 = socket (AF_INET, SOCK_STREAM, 0); bind (sa, server, slen); listen (sa, 5); sa1 = EMU_accept (sa, & client, &clen); EMU_connect (sb0, server, slen); EMU_read (sa1, buffer1, length1); EMU_write (sb0, buffer0, length0); EMU_read (sa1, buffer1, length1); EMU_write (sb0, buffer0, length0); ・ ・ ・ ・ ・ ・ close (sa1); close (sa); close (sb0);
Call system calls for pocket, bind, and listen. These system calls are processed by the corresponding TCP / IP processing routine in a conventional manner. The client-side application program also issues a socket system call in the same manner as in the related art. This system call is also processed by the corresponding TCP / IP processing routine in the same manner as in the related art. Thus, the sockets sa and sb for the server side and the client side in the same manner as before.
0 is generated.

Thereafter, the server-side application program replaces the conventional system call accept with a function emulation accept (EMU) provided in a TCP / IP emulation library provided in a computer on which the application program is running.
_Accept). The client-side application program calls a function emulation connect (EMU_connect) provided in a TCP / IP emulation library provided in a computer on which the application program is running, instead of the conventional function connect. Further, the server-side application program calls a function emulation read (EMU_read) provided in the TCP / IP emulation library instead of the conventional system call read, and the client-side application program replaces the conventional system call write. Call the function emulation light (EMU_write) provided in the corresponding TCP / IP emulation library. Hereinafter, processing performed by these new functions will be described.

(4) Socket Connection by TCP / IP Emulation Library In FIG.
The client-side application program executes the above-described EMU_accept and EMU_connect, respectively.
When the t function is called (processes 501 and 502), the function EMU_ac provided in the TCP / IP emulation library on the server side by these system calls
CMU and EMU_connect provided in TCP / IP emulation library on the client side
Be called. The arguments of these system calls are as follows: the server-side application program and the client-side application program execute the system call a
call cept, connect, socket sa,
The connection of sb0 is changed to the TCP / IP processing routines 114 and 11
5 is the same as when requesting.

The called functions EMU_accept and EMU_connect first issue an accept system call and a connect system call, respectively (processes 503 and 504). The arguments of these system calls are the functions EMU_accept, EMU_con
The argument for each nect is used as is. As a result, the system call "accept" provided in the TCP / IP processing routine on the server side and the system call "connect" provided in the TCP / IP processing routine on the client side are called. Upon receiving the connection request issued by the called system call connect, a socket sa1 is generated and the socket s
a1 and the socket sb0 are connected via the communication path 106.

Then, the function EMU_accept, EM
U_connect confirms whether the IP address of the other party is an address of a computer inside the parallel computer 101 (steps 506 and 507). If the partner is inside the parallel computer 101, the socket descriptor is registered in the internal table 410 or 411 (steps 510 and 5).
11). In this case, the socket sa1 for the application program 107 on the server side and the socket sb0 for the application program on the client side are registered in the internal tables 410 and 411, respectively. Further, the TCP / IP emulation libraries 112 and 113 exchange data necessary for using the high-speed communication mechanisms 116 and 117 such as the identifier of each computer in the parallel computer 101. For this data exchange, the application programs 107 and 108 issue function read and write system calls, respectively (processing 512, 513, 515 and 516). The data exchange here is performed by the already connected sockets sa1 and s
Using b0, TCP / IP processing routines 114 and 115 and a communication path 106 are performed in the same manner as in the related art. Thereafter, the process returns to the server-side and client-side application programs 107 and 108, respectively (process 51).
8, 519). At this time, the server side TCP / IP emulation library 112 returns the generated identifier of the socket sa1 to the application program 107.

When it is determined in the processes 506 and 507 that the other party is not a computer inside the parallel computer 101, the function EMU_connect returns to the client-side application program 108, and the function EMU_connect is returned.
The accept returns the socket sa1 to the application program 107 on the server side, and returns to the program (processing 508, 509). Thus, the socket sa1 for the application program on the server side and the socket sb0 for the application program on the client side are connected to the corresponding TCP / IP processing routine via the communication path 106.

FIG. 3 shows one state in which the sockets generated by the application programs 107, 108, and 109 according to the present embodiment are connected to each other. Here, the application program 107
The socket SA1 (402) of the application program 108 and the socket SB0 (403) of the application program 108 are connected (407), and the socket SB1 (404) of the application program 108 and the application program 1 are connected.
09 socket SC0 (405) is connected (40
8), socket S of application program 109
C1 (406) and the socket SA0 (401) of the application program 107 are connected (40).
9). Here, the TCP / IP emulation libraries 112 and 113 store the internal socket tables 410 and 4 respectively.
11 is held. Internal socket tape 410, 41
1, when the connection destination of the socket is an internal computer,
Register that socket descriptor. For example, the socket SB0 (403) to which the socket SA1 (402) of the application program 107 is connected is the internal computer 1
Since SA is the socket of the application program 108 that operates on SA 03, SA1 is registered in the internal socket table 410. Similarly, since the socket SA1 to which the socket SB0 is connected is the socket of the application program 107 running on the internal computer 102, SB0 is registered in the internal socket table 411. On the other hand, the socket SC1 (40) to which the socket SA0 (401) is connected is connected.
6) The application program 10 on the external computer
9 socket, SA0 is the internal socket table 4
No registration for 10. Similarly, SB1 connected to SC0 is not registered in internal socket table 411.

(5) Method of separating internal communication from external communication After that, the application program on the server side and the application program on the client side start data communication. One and the other of these two programs use the function EMU_ for data transmission and reception.
Write and EMU_read are called respectively. In the example of the client-side and server-side programs described above, the server-side application program executes the function E
MU_read is called, and the client-side application program calls the function EMU_write. The arguments specified by these are the system call wr included in the TCP / IP processing routines 114 and 115.
Same as arguments for item and read.

Referring to FIG. 4, EMU_read, E
When MU_write is called (processing 701, 70
2) The respective functions determine whether or not the socket descriptors of the sockets sa1 and sb0 specified by the respective arguments are registered in the corresponding internal socket tables 410 and 411 (steps 703 and 704). Each socket identifier is an internal socket table 410,
If they are registered in 411, respectively, message-passing communication is performed using the high-speed communication mechanisms 116 and 117 and the high-speed internal communication network 105 in a procedure described in detail later (processing 707 and 708). If the respective socket identifiers are not registered in the internal socket tables 410 and 411, the conventional read, write
A system call is issued to each specified socket (processes 705 and 706). These system calls correspond to the corresponding TCP / IP processing routines 114 and 11.
5 and the TCP / IP processing routines 114 and 115
Is executed by

FIG. 5 shows each application program 10 in the connection state of the socket shown in FIG.
FIG. 7 is an overall configuration diagram illustrating a data flow in a case where 7, 108, and 109 communicate with each other, and illustrating the above-described separation method. When the application program 107 and the application program 108 communicate, the socket sa1 (402) and the socket sb0 (403) are used as communication ends. These sockets are TCP / IP
It is registered in the internal socket tables 410 and 411 held by the emulation libraries 112 and 113. So TCP / IP emulation library 1
12 and 113 are not TCP / IP processing routines 114 and 115 but high-speed communication mechanisms 116 and 1 for data communication processing.
17 is used (601). On the other hand, when the application program 108 and the application program 109 communicate, the socket SB1 (404) and the socket SC0 (405) are used as communication ends. TCP / IP linked to application program 108
SB1 is not registered in the internal socket table 411 held by the emulation library 113.
Therefore, the TCP / IP emulation library 113
Is a TCP / IP processing routine 11 for data communication processing.
5 is used as it is (602). As a result, data exchange with the external TCP / IP processing routine 110 becomes possible.

According to this method, a bind system call,
The listen system call can be used without any change from the conventional TCP / IP processing routine to realize the separation between internal communication and external communication.

(6) Message passing type libraries 140 and 141 Internal high-speed communication network 10 used for each computer of the parallel computer
Since the communication hardware 119 and 120 and the high-speed communication libraries 135 and 136 for using the H.5 are often vendor-specific, their usages also vary depending on the machine. Therefore, when trying to create an application program using the high-speed communication hardware and the high-speed communication library of each machine, the program must be a low-versatility program specialized for the machine. On the contrary,
A library for communication using the communication hardware inside the parallel computer is prepared, and activities to increase the versatility of application programs by defining the application program interface of this library as a standard are active worldwide. is there.

An interface widely used at present as a general-purpose interface for using this message type communication is a message passing interface (MPI-Message Pass) called MPI.
ing Interface). For example, reference: "MPI: Message Passing Interface Standard versi
on1.1 ", MPI Forum, University of Tennessee, 1995
reference. This interface is based on the premise that the above-mentioned high-speed communication library for implementing message-passing type communication exists. Even if this interface is used, message-passing type communication can Is still realized by the high-speed communication library.

Many parallel computer vendors provide high-speed communication libraries that enable application programs compliant with MPI to use high-speed communication hardware inside the parallel computer.

In this specification, an interface for using message type communication is called a message passing type interface, and a library having the interface is called a message passing type library. In particular, MPI or MPI interface
It is called an I interface or a message passing interface, and a library having the interface may be called an MPI library or a message passing interface library.

In the present embodiment, a library for exchanging commands or data with an interface defined by a standard MPI specification that can be used in many parallel computers is used as the message passing type libraries 140 and 141. Therefore, the versatility of the TCP / IP emulation libraries 112 and 113 is improved. However, other specification interfaces may be used.

A description example of a conventional application program conforming to MPI is shown below. In the present embodiment,
TCP / IP emulation libraries 112 and 11
3 is a message passing type library 140, 14
1 has the following program part. More details on this part of the program will be mentioned later.

MPI_Init (& argc, &argv); MPI_Comm_rank (MPI_COMM_WORLD, &rank); if (rank == 0) / * receiver * / MPI_Recv (buffer, length, type, 1, tag, comm, status); else if (rank == 1) / * sender * / MPI_Send (buffer, length, type, 0, tag, comm); MPI_Finalize (); In MPI, all processes that want to communicate are started at once. At this time, a process identifier called a rank is determined for each process. The above example shows a case where two processes are started, that is, a sender process sender and a receiver process receiver. At this time, ranks 0 and 1 are assigned to the respective processes. Each process starts with an MPI initialization function MPI
MPI is initialized by _Init, and its own rank is acquired by MPI communication rank function MPI_Comm_rank. After that, processing for each rank is performed. The above example shows a case where the process of rank 0 receives data transmitted by the process of rank 1 by the MPI transmission function MPI_Send by the MPI reception function MPI_Recv.

(7) Message-passing type communication using high-speed communication mechanism Data reception processing 7 using high-speed communication mechanisms 116 and 117
07, before describing the details of the data transmission processing 708, the high-speed communication mechanisms 116 and 11 required to execute these processing are described.
The outline of the message-passing type communication using No. 7 will be described.

In general, to execute message-passing type communication, a computer on the transmitting side executes a transmission function for transmitting data, and a computer on the receiving side executes a receiving function for receiving the data. These functions are repeatedly executed to transfer subsequent data between the computers. In the present embodiment, message passing communication according to the MPI specification will be described as a specific description of message passing communication.

In the message passing communication according to the MPI specification, the computer on the transmission side executes a transmission function MPI_Send, and the computer on the reception side executes the reception function MPI_Recv. In this case, when the transmission process 708 is activated,
Transmission side TCP / IP emulation library 11
3 calls the transmission function MPI_Send as in the example of the application program of the MPI specification described above. Before calling the transmission function MPI_Send, MPI_Init, MPI_Com
It is necessary to execute a call to a function such as m_rank, and these processes are performed by the function EMU_acc described above.
ept, performed at the same time as the internal table registration processing (510, 511) in the EMU_connect. On the other hand, the TCP / IP emulation library 112 on the receiving side
Is a receiving function MP for using the internal high-speed communication network 105.
Call I_Recv.

The buffer address b specified by the argument of the function MPI_Send called by the TCP / IP emulation library 113 on the transmission side in the transmission processing 708
buffer and the buffer length length are the functions EM issued by the application program 108 on the transmission side.
It is equal to the corresponding argument of U_write. on the other hand,
TCP / IP emulation library 11 on the receiving side
2 calls function MPI_Recv in reception processing 707
The buffer address buffer and the buffer length specified by the argument are the buffer address and the buffer length specified by the argument of the function EMU_read or the TCP / IP emulation library on the receiving side issued by the application program 107 on the receiving side as described later. It is equal to the address and size of the particular buffer provided in 113.

When the function MPI_Send in the message-passing type library 141 on the transmitting side is activated,
For the corresponding high-speed communication library 136, the function MPI
A request is made to transfer data of the length specified by the argument from the buffer at the address specified by the argument to _Send to the computer 124 on the receiving side via the internal high-speed communication network 105. When the function MPI_Recv in the message-passing type library 140 on the receiving side is started, the function MPI_Recv receives the transferred data via the internal high-speed communication network 105 to the corresponding high-speed communication library 135. Then, a request is made to write data of the length specified by the argument to the buffer at the address specified by the argument for the function MPI_Recv.

The activated high-speed transfer library 1 on the transmitting side
36 and the high-speed transfer library 135 on the receiving side transmit and receive the requested data via the internal high-speed communication network 105 by a method known per se. This data transfer is specifically performed as follows. Generally, a command called a remote memory write command or a PUT command is used. In the following, this command is called PUT
Called a command. A communication method for performing data transfer via the internal high-speed communication network 105 is performed by three PUT commands.

First, when the function MPI_Send is called from the TCP / IP emulation library 113 on the transmitting side, the message passing type library 141 on the transmitting side sends the buffer length specified by this argument (that is, the length of the data to be transmitted). The first PUT command is issued to request the high-speed transfer library 136 on the transmission side to transmit a header including the attribute information of the data including the following. The high-speed transfer library 136 transmits the header to the computer 102 on the receiving side. The hardware 119 dedicated to internal high-speed communication in the computer 102 directly writes this data to a predetermined position in the memory 124 on the receiving side.

On the other hand, when the receiving command MPI_Recv is called from the TCP / IP emulation library 112 on the receiving side, the message passing type library 140 on the receiving side first checks whether the header has already been sent from the computer 103 on the transmitting side. For this purpose, a data check instruction MPI_probe described later is used. When the header has not been sent, the execution of the reception instruction ends. If the header has already been sent, it is determined from the buffer length in the header whether the transmission data can be received. That is, it is determined whether or not the length of the transmission data is equal to or less than the buffer length specified by the reception command MPI_Recv. Not only in the message passing communication of the MPI specification, but generally in the message passing type communication, when the transmission data length specified by the transmission command is larger than the reception buffer size specified by the reception command, the receiving computer receives the transmission data. Not to be. This is because if the receiving computer receives received data exceeding the size of the receiving buffer, a memory area other than the buffer may be damaged by the received data. When the message passing type library 140 on the receiving side determines that the transmission data is receivable as a result of the above determination, the message passing type library 140 on the receiving side transmits the address of the receiving buffer designated by the argument to the receiving instruction MPI_Recv.
Issue a second PUT command. The high-speed communication library 135 transmits the buffer address to the transmitting computer 103 as a response to the command. Internal high-speed communication dedicated hardware 119 in 102
Writes this address in a predetermined position in the memory 125 on the transmission side. As a result of the determination, when the transmission data is not receivable, the message-passing type library on the receiving side does not return the buffer address, but notifies the computer on the transmitting side of the error.

Finally, the message-passing library on the transmitting side issues a third PUT command requesting the high-speed transfer library 136 on the transmitting side to transmit the transmission data and the received buffer address. The high-speed transfer library 136 transmits the data and the buffer address to the computer 102 on the receiving side. The internal dedicated hardware 119 for high-speed communication in the computer 102 on the receiving side receives the buffer address and the data, and directly writes the received data to the buffer having the address. Thus, the data transfer ends.

The data communication method via the internal high-speed communication network 105 is not limited to the above method, and other methods can be used. For example, depending on the parallel computer, the high-speed communication library can execute a remote memory write command or a GET command in addition to the PUT command. In such a parallel computer, instead of the message-passing type library 141 on the transmitting side issuing the third PUT command, the message-passing type library 140 on the receiving side issues a GET command and issues a GET command. The high-speed communication library 135 executes a process of reading out transmission data from the memory 125 on the transmission side.

(8) Stream Communication in Message Passing Type Communication Data reception processing 707 and transmission processing 708 shown in FIG.
Will be described with reference to the specific examples shown in FIGS. In FIG. 4, as described above, the application program 108 on the transmission side performs the function EMU_write
When the transmission process 708 is activated as a result of calling e (702), the function MPI_Send included in the message passing type library 141 is called (78).
1). In the example shown in FIG. 7, it is assumed that the address Sbuff of the buffer 803 and the buffer size of 50 kilobytes (KB) are specified in the argument at the time of calling the function EMU_write (702). The buffer address and buffer size specified by the argument at the time of calling the function MPI_Send (781) are made equal to these values. In the following, description of other arguments of the function to be used is omitted for simplification. Also, it is assumed that the unit of the designated buffer size is KB, and when the arguments of the function are illustrated, the unit KB is not illustrated for simplicity. In response to the function call 781, the message-passing type library 141 instructs the high-speed communication mechanism 117 to transmit a header as described above, and then instructs data transmission for data transfer.

On the other hand, in FIG. 4, as described above, the application program 107 on the receiving side executes the function E
When the reception process 707 is activated as a result of calling MU_read (701), the reception process 707 performs the process shown in FIG. In the example shown in FIG. 7, the buffer address specified by the argument of the call 701 of the function EMU_read is Rbuff, the buffer size is 30 KB, and a size smaller than the buffer size specified by the call 702 of the transmission function EMU_write is specified. Suppose you are.

In the receiving process 707, first, the data has been received by a specific data receiving buffer (a buffer 901 described later) provided in the TCP / IP emulation library 112 on the receiving side and is transferred to the application program on the receiving side. An instruction to determine whether or not unremained data remains is issued (process 202). This instruction is not shown in FIG. The first time the function EMU_read is executed, as now assumed, the result of this determination is negative. After that, the transmission data detection instruction MP
I_probe 771 is issued, and it is determined whether there is data to be transmitted to the application program on the receiving side (process 206). This instruction is, specifically, an instruction for determining whether or not the already described header regarding data to be transmitted to the application program 107 has been received by the high-speed communication mechanism 116. If the header has not been transmitted from the application program 108 on the transmitting side, the receiving process 708 ends the process and returns to the receiving application program 107 (process 207). The receiving-side application program 107 executes processing when reception has failed. For example, the function 701 is repeatedly called until the reception is successful.

Assuming that the header has already been transmitted from the application program 108 on the transmitting side, it is determined whether or not the transmission data specified by the header can fit in the buffer 812 of the application program on the receiving side (step 208). ). In the example of FIG. 7, the size of the transmission data is 50 KB, the size of the buffer 812 on the receiving side is 30 KB, and the result of this determination is negative. In such a case, the TCP / IP emulation library 112 on the receiving side stores the transmission data in the buffer 812 of the application program 107 on the receiving side.
When the MPI_Recv command to be received is issued, the message-passing type library 140 on the receiving side normally processes this command as an error according to the MPI specification or does not fit in the buffer 812 of the application program on the receiving side out of the transmission data. Discard the minute.

To prevent this, in the present embodiment, the receiving side TCP / IP emulation library 112 linked to the receiving side application program 107
, A special buffer 901 is prepared and TCP /
The IP emulation library 112 requests that the buffer 901 once receive transmission data. That is, the address Ebuf of the buffer 901
Call the function MPI_Recv, which specifies f and the size of all transmission data 50 KB (772).

In response to this function call 772, the high-speed communication mechanism 116 on the receiving side and the high-speed communication mechanism 117 on the transmitting side
Transmits and receives data as described above, and the high-speed communication mechanism 116 on the receiving side transmits the data to the buffer 9.
Write to 01. The TCP / IP emulation library 112 on the receiving side then performs a memory copy instruction (MEMCPY) for copying the data of the size 30 KB specified by the argument at the time of calling the function EMU_Read from the received data to the buffer 812 of the application program 107 on the receiving side. (Rbuff, Ebuff, 30K
B)) 773 is issued (process 209). Thereafter, the process returns to the application program (process 211). Thus, the TCP / IP emulation library 11
Part 906 of data received in buffer 901 in
The transmission and reception between the application programs are completed in the state in which.

Thereafter, the transmitting side application program 108 further stores the buffer 804 of the address Sbuff '.
Function EMU_wr to transmit 80 KB of data
te (Sbuff ', 80 KB) (790) (FIG. 7)
When (B)) is called, the transmission processing 708 is executed in the same manner, and in this processing, the function MPI_Send (Sbu
ff ', 80) (791) is called. On the other hand, the receiving side application program 107 also stores the address Rbu.
To receive 100 KB of data in the buffer 813 of the ff ′, the function EMU_read (Rbuff ′, 100
When KB) (775) is called, reception 707 is similarly executed.

This reception processing 707 is the first judgment processing 2
02, the receiving buffer 901 in the TCP / IP emulation library 112 on the receiving side is determined.
It is determined that untransferred data 906 remains in the data.
As a result, the memory copy instruction memcpy (Rbuf
f ′, Ebuff + 30 KB, 20 KB) (776), and the data 906 is stored in the head area 90 of the buffer 813 in the application program 107 on the receiving side.
7 (process 203). The length of the data to be memory-copied is the second of the length of the data held in the buffer 901 with respect to the function EMU_read.
Is set to a range that does not exceed the buffer length specified by the function call of. In this case, since the length of the data held in the buffer 901 is 20 KB and the length of the data requested to be received is smaller than 100 KB, the entire 20 KB of the data is copied.

Thereafter, the process 206 is executed to further receive the remaining data of 80 KB requested by the receiving-side application program 107. This processing 206
As described above, the instruction MPI_Probe () for checking whether or not there is transmission data is issued. Specifically, it is determined whether a header for the transmission data has been received. In this case, assuming that the function call 791 on the transmitting side has already been executed, 80K
It turns out that there is transmission data of B. In that case,
It is determined whether the size of the transmission data can fit in the buffer 813 specified by the receiving-side application program 102 (process 208). In this case, the size of the remaining area 908 of the buffer 813 of the application program on the receiving side is 80 KB, so that the transmission data can fit in this area 908 of the buffer 813.

As a result, the function MPI_Recv (Rbu
ff ′ + 20 KB, 80 KB) (778) is called. This function call specifies the address of the remaining area 908 of the buffer 813 and the size of the transmission data of 80 KB. Thus, the transmission data is directly received in the area 908 of the buffer 813 (process 210). Thereafter, it is determined whether or not all the data requested to be received has been received (process 212). In this case, since the result of the determination is positive, the receiving process 707 ends, and the process returns to the application program (process 211).

According to the above procedure, a plurality of functions EMU_w
It is possible to realize stream communication in which transmission data specified by the call of write (702, 790) is received as a continuous data stream by calling EMU_read (701, 775) of a plurality of functions.

Even when the size of the transmission data specified by the application program on the transmission side is smaller than the size of the buffer specified by the application program on the reception side, stream communication can be easily realized as follows. For example, a description will be given of stream communication in a case where a transmission-side application program repeatedly requests transmission of 50 KB data and a reception-side application program requests reception of 100 KB data, with reference to FIG.

In the transmission processing 708 (FIG. 4) for the function EMU_write (702) called by the application program on the transmission side, the function MPI_send (7
81) is called. In this function call, the address Sbuff and the size 50 KB of the buffer 803 of the transmission side application program are specified.

The reception process 707 (FIG. 4) for the function EMU_read (701) called by the application program on the reception side is also processed according to FIG. 6 as described above. Under the current assumption, the determination in the process 202 fails. Assume that in process 206, when the data check instruction 771 is executed, it is determined that there is transmission data. In this case, the size of the buffer 812 on the receiving side is
Since it is larger than the size of the buffer on the transmission side, the process 208
The result of the determination in is positive. As a result, the process 210
Is executed. In this process, a function MPI_recv (774) for directly receiving transmission data in the buffer 812 specified by the receiving-side application program is called. This function call is performed at the start address Rbu of the buffer 812 of the receiving side application program.
ff and the size of the transmission side buffer 803 of 50 KB are designated. In this way, all data in the buffer 803 on the transmission side is written to the first 50 KB area 907 in the buffer 812 on the reception side. Next, the process 212 is executed.
In this case, the size of the data requested to be received is 100K
B, whereas the size of the data already received is 50 KB. Thus, some of the requested data has not yet been received. Therefore, the result of decision 212 is negative, and process 206 is executed again to receive the remaining data.

If the transmitting application program next calls the function EMU_write 790,
In the transmission processing 708 (FIG. 4) corresponding thereto, the function MP
I_send (791) is similarly called. Even in this function call, the address Sbuff 'and the size 5 of the buffer 804 next to the transmission side application program are used.
Specify 0KB.

If the application program on the transmitting side has already called the next function EMU_Send 791 when repeating the above processing 206, the result of the determination in the processing 206 becomes affirmative and the determination processing 208
Move on to In this case, the result of this determination is positive because the size of the remaining area 910 of the receiving buffer 812 is equal to the size of the data to be transmitted. As a result, the process 210 is executed, and the second reception function 779 for directly writing the transmission data to the remaining area 910 of the buffer 812 on the reception side is called. In this function call, the address Rbuff + 5 of the remaining area 910 of the buffer 812 of the receiving side application program is used.
Specify 0 KB and the size of the transmission data 50 KB. Thus, in the process 212, it is determined that the reception of all the requested data has been completed, and the reception process 707 is completed. If there is no transmission data at the time when the above-described processing 206 is repeatedly executed, the reception processing 70
7 ends, and the process returns to the receiving application program. Also, when the above-mentioned process 208 is repeated,
When the result of the determination at step 208 is negative, step 209 is executed. The contents of this processing are the same as those already described. As described above, the transmission instruction EMU_wr issued by the transmission-side application program
The size of the buffer specified by te and the reception instruction EMU_read issued by the application program on the reception side
If the size of the buffer specified by is different,
It can be seen that the buffer stream communication can be realized even if the number of transmission instructions EMU_write issued by the application program on the transmission side is different from the number of reception instructions EMU_read issued by the application program on the reception side.

As can be understood from the above description, according to the present embodiment, applications running on a computer provided with a high-speed communication mechanism of a message passing communication system, such as inside a parallel computer, can communicate with TCP / IP. When performing data communication using, high-speed communication utilizing the features of the high-speed communication mechanism becomes possible. In addition, with applications running on other computers, communication by TCP / IP as usual is guaranteed. The user does not need to change any existing TCP / IP application.

<Modifications of First Embodiment of the Invention> The present invention is not limited to the contents of the first embodiment, but includes various modifications including the following modifications and other modifications. Can be implemented.

(1) Although TCP / IP is used as the communication protocol of the wide area network, another communication protocol may be used instead. At that time, it is needless to say that the TCP / IP processing routine and the emulation library need to be changed.

(2) In the first embodiment, the message passing type library is used, but it is also possible not to use this. At this time, the emulation library directly calls the high-speed communication library.

(3) Further, it is possible to eliminate this communication library. For example, a dedicated circuit can be used instead.

(4) In the first embodiment, it is assumed that all internal computers are connected to a wide area communication network. However, the present invention can be similarly applied to a case where some internal computers are connected to a wide area communication network.

(5) In the first embodiment, it is assumed that both the wide area communication network and the internal high speed communication network are used. However, the stream communication itself according to the present invention can be applied between computers capable of executing message-passing type communication. Therefore, in order to execute the stream communication, message passing without using TCP / IP communication is performed. It can also be applied to communication between application programs that use only type communication. In this case, it is not necessary to use a plurality of types of communication networks. In that case, a modification example in which the emulation library on the transmission side is not substantially used is also possible.

<Second Embodiment of the Invention> The TCP / IP processing routine has conventionally been provided with a select function as a function that can be used by an application program. In the first place, a socket descriptor is defined as a kind of file descriptor. As a system call to check whether data can be obtained from the object specified by this file descriptor,
A ct function is provided. For example, whether or not data that can be received from a certain socket has been sent (or is about to be sent) from the sender is also determined by sel.
It can be checked by an ect function. Specifically, it can be determined whether or not an application program to which a certain socket is assigned has issued a transmission system call write. In the select function, a file descriptor to be monitored is specified by a bit string. Each bit of this bit string corresponds to an individual file descriptor, and setting the bit to 1 designates the file descriptor. If a plurality of bits are set to 1, one select
Functions can watch multiple file descriptors simultaneously. The select function blocks until one of the watched file descriptors is ready to receive data.

TCP / IP used in Embodiment 1 of the Invention
The emulation library does not use the conventional socket library for communication inside the parallel computer.
The select system call cannot check whether data can be received from the internal communication socket. Therefore, in the present embodiment, even in a computer system that uses the TCP / IP emulation library as in the first embodiment, the application program can use the select function as in the related art.

In the present embodiment, processing corresponding to “select” dedicated to internal communication is performed on socket descriptors registered in the internal socket tables 410 and 411, and other file descriptors are processed. Is the traditional s
The select function EMU_select, which separates the use of the
Provided in the P / IP emulation library 113.

However, select and se for internal communication are used.
The select system call must be executed simultaneously and in parallel. By executing two select operations sequentially, for example, while the internal communication select is waiting for data, even if the external communication socket or the standard input / output is ready to receive data, Because it cannot be detected.

As a means for simulating the simultaneous execution of select, a method of repeatedly issuing the internal select and the select system call in a non-blocking manner repeatedly in a spin loop is conceivable. However, if this method is used, the computer is occupied until data can be received, and the process cannot be passed to another process running on the same computer.

On the other hand, in the present embodiment, a method is employed in which an instruction for transferring the process to another process is inserted for each loop. With this method, the computer occupation by the spin loop can be avoided.

FIG. 9 shows the state in the connection state shown in FIG.
The application programs 108 and 109 issue transmission commands 1002 and 1003 to transmit data to the application program 107, and the application program 107 determines that the data has arrived at sel.
It shows a state of being watched by an ect instruction 1001.
It is assumed that the bit string specified by the select instruction 1001 corresponds to sockets SA0 and sa1 (10
04, 1005). Among them, sa1 is registered in the internal socket table, so that it is monitored by internal select (1008). On the other hand, since SA0 is not registered in the internal socket table, it is monitored by the select system call (1009). Since the select system call issued by the TCP / IP emulation library does not need to monitor sa1, a bit string in which the bit corresponding to sa1 is set to 0 is specified for the bit string specified by the select instruction 1001 issued by the application program 107. I do. Processing 1008 and 100
9 is issued non-blocking and alternately repeated (10
10, 1011). However, the process is temporarily transferred to another process during the repetition.

In order for the application program to be able to use the select instruction and the internal select function shown in FIG. 9, the TCP / IP emulation libraries 112 and 113 are provided with an emulation select function EMU_select. , Call and use this. When the application program calls the EMU_select function, a bit string ap_bits composed of bits corresponding to one socket is specified as in the related art. The TCP / IP emulation library executes processing according to FIG. 10 in response to the function call.

First, a mask is applied to the bit string ap_bits (step 1101) to set the bit corresponding to the socket descriptor registered in the internal socket table to 0 (step 1102). in_mask is
The bit string is such that the bits corresponding to all socket descriptors registered in the internal socket table are 0, and the other bits are 1. Therefore, a bit string ex_bit created by multiplying ap_bits by in_mask
s is a bit string excluding the socket descriptor for internal communication from the file descriptor specified by ap_bits. After that, select using ex_bits as an argument
The system call and the internal select processing are executed once each in a non-blocking manner (processing 1103, 110
4) If any of the file descriptors checked in this process is in a data receivable state, the process returns (process 1106). If not, the process is temporarily transferred to another process (process 1107), and select is performed again.
The t processing is repeated (processing 1108).

As described above, according to the present embodiment, even in the computer system using the internal high-speed communication mechanism as in the first embodiment, the application program
The ect function becomes available.

<Embodiment 3> In the above-described method for realizing a select function by a spin loop, the occupation of a computer is avoided by inserting a process 1107 for transferring a process to another process in the middle of the spin loop. If the priority of a process processed on the same computer is low, the process may not be passed to that process. This can be avoided by using a blocking weight that sleeps and waits for the arrival of data.
The ect system call cannot be executed simultaneously on one process and one thread.

On the other hand, in the present embodiment, first, two threads are generated, and on one thread, the internal thread is generated.
Select, and the other is to execute the select system call. According to this method, since the internal select and the select system call can operate independently on each thread, it is possible to block and watch data at the same time.

FIG. 11 shows the same communication state as that shown in FIG. However, internal select and select
The method of realizing the simultaneous execution of the ct system call is different. In FIG. 11, these two select processes are executed on separate threads (1203, 1204). Processing 1
Similarly to 009, in the select system call on the thread 1203, a bit string in which the bit corresponding to sa1 is set to 0 is specified.

Referring to FIG. 12, in the present embodiment, the application program is EMU_select
Bit string ap_bits specified when issuing the t function
On the other hand, the process up to the process of creating ex_bits by applying a mask for setting the bit corresponding to the socket descriptor registered in the internal socket table to 0 is the same as the process (1101, 1102) in FIG. 1301,
1302). Then, first, non-blocking and sele
ct system call (process 1303) and internal cell
The ct process (process 1304) is performed once. If any of the file descriptors checked in this process are in a data receivable state, the process returns. If not, two threads are generated (process 1307), and a select system call (process 1308) and an internal select (process 1309) are executed on each of them. These processes block until a data receiving state is attained. If the block is solved first in both processes,
Cancel the other thread (process 1310,
1311) Return (processing 1314, 1315).
In this canceling process, instead of forcibly terminating the thread, the thread is marked as unnecessary. The thread checks whether or not this mark is added when the block is unwound (processing 1316, 131
7) If it is attached, it means that it has been cancelled, and it is deleted as it is (processing 1318, 131)
9).

In the above-described select processing, the non-blocking select processing of the processing 1303 and the processing 1304 is performed once before thread division for the following reason. If both the internal socket and the other file descriptors are ready to receive data before the processing 1301 is issued, the select function must be able to detect both. However, if you split the thread and start watching the internal socket and other file descriptors separately, one of the two threads will detect the other thread slightly earlier and cancel the other thread. Only the state can be detected. On the other hand, by executing the processing 1303 and the processing 1304, it is possible to reliably check both the state of the internal socket and the state of the other descriptors before the processing 1301 is issued.

In this method, the data is asleep while waiting for the arrival of data, so that the data detection timing is delayed as compared with the method of waiting in the spin loop of the second embodiment. Can be avoided.

[0125]

According to the present invention, stream communication can be realized by message passing type communication.

According to another aspect of the present invention, an application program running on a computer connected to a first communication network and a higher speed second communication network is connected to the first communication network. It is possible to communicate with another application program running on another computer based on the first communication protocol, and further, another application running on another computer connected to the second communication network. High-speed communication can be performed with the program using the second communication network.

More specifically, the first communication protocol can use a TCP / IP communication protocol. The communication using the second communication network can be a message passing type communication.

[Brief description of the drawings]

FIG. 1 is an overall configuration diagram of an embodiment of the present invention.

FIG. 2 is a flowchart of socket connection.

FIG. 3 is a diagram illustrating socket connection.

FIG. 4 is a flowchart of an internal / external communication separation method.

FIG. 5 is a view for explaining an internal / external communication separation method.

FIG. 6 is a flowchart of stream communication.

FIG. 7 is a diagram showing an example of an instruction sequence used for a transmission / reception operation.

FIG. 8 is a diagram showing another example of the instruction sequence used for the transmission / reception operation.

FIG. 9 is a view for explaining a method of realizing a select function by a spin loop.

FIG. 10 is a flowchart of a method for implementing a select function by a spin loop.

FIG. 11 is a view for explaining a method of realizing a select function using a thread.

FIG. 12 is a flowchart of a method for implementing a select function using a thread.

FIG. 13 is a hierarchical diagram of a conventional TCP / IP communication protocol.

FIG. 14 is a diagram for explaining conventional stream communication.

[Explanation of symbols]

105. . . Parallel computer internal communication network, 106. . . Global Communication Network, 111. . . Socket application program interface, 118. . . Interface of MPI specification, 119, 120, 121, 122, 1
23. . . Network interface hardware,
140, 141. . . Message passing type library, 401, 402, 403, 404, 405, 40
6. . . Socket, 407, 408, 409. . . Socket connection, 410, 411. . . Internal socket table, 601. . . Data path at the time of parallel computer internal communication, 602. . . Data path at the time of communication with an external computer, 803, 804, 812, 81
3. . . Application program buffer, 80
9. . . Stream, 901. . . Buffer in TCP / IP emulation library.

Claims (12)

[Claims] A plurality of transmission data specified by a plurality of transmission instructions issued by a first application program executed on a first computer, each of the plurality of transmission data being executed on a second computer; A plurality of transmission data received in response to a plurality of reception instructions issued by the second application program under message-passing communication under the control of an emulation library provided on the second computer. Among the connected data, each received transmission data is stored in a plurality of buffers specified by the respective reception instructions so that a portion obtained by dividing the data into the size part specified by the plurality of reception instructions is stored in the plurality of buffers specified by the respective reception instructions. An inter-computer data transmission / reception method that processes under the control of the emulation library. 2. In response to a plurality of transmission instructions issued by a first application program running on a first computer having a first communication library for executing message-passing type communication, A plurality of transmission commands requesting transmission of a plurality of transmission data held in a plurality of buffers specified by the first transmission command by the first emulation library provided in the first computer. In response to a plurality of receiving instructions issued by a second application program running on a second computer having a second communication library for issuing message-passing type communication to the library. A plurality of receiving instructions for receiving the plurality of transmission data by message-passing type communication, A second emulation library provided in the computer of the second computer, the second emulation library issues to the second communication library, and the first emulation library issues a plurality of transmission data specified by the plurality of transmission instructions issued by the first emulation library. According to the plurality of reception instructions issued by the second emulation library, the connected data is divided into size portions designated by the plurality of reception instructions and stored in a plurality of buffers designated by the respective reception instructions. Inter-computer data transmission / reception controlling the storage positions of the received plurality of transmission data in the second computer and the movement of the plurality of transmission data in the second computer after receiving the respective transmission data by the second emulation library. Method. 3. In response to a plurality of transmission instructions issued by a first application program executed on a first computer having a first communication library for executing message-passing type communication, A plurality of transmission instructions requesting transmission of a plurality of transmission data held in a plurality of buffers specified by the transmission instructions, respectively.
Issued to the first communication library by a first emulation library provided in the first computer, on a second computer having a second communication library for executing message-passing type communication. In response to the plurality of reception instructions issued by the second application program being executed, the second computer is provided with a plurality of reception instructions for receiving the plurality of transmission data by message passing communication. A series of data that are issued to the second communication library by the obtained second emulation library and are formed by linking a plurality of transmission data specified by the plurality of transmission instructions issued by the first emulation library. Is specified by multiple receiving instructions issued by the receiving application program. The second emulation library (a) allows each of the plurality of reception instructions issued by the second emulation library to be stored in a plurality of buffers separately in a size portion designated by each reception instruction. The address of the buffer for storing the received data to be specified is set to the address belonging to the buffer specified by the reception command issued by the second application program currently being processed or the address belonging to the buffer usable by the second communication library. And (b) specifying the address of the buffer that can be used by the second communication library, and the first transmission data received by a reception command issued by the second emulation library. Controls movement within the computer and generates a second emulation license. The plurality of reception instructions issued by the Rally are respectively issued corresponding to one of the plurality of transmission instructions issued by the first emulation library, and each of the plurality of reception instructions issued by the second emulation library is issued. Is set to be equal to the size of the transmission data specified by the corresponding one of the plurality of transmission instructions issued by the first emulation library. Method. And (a) issuing, within the computer on the transmission side, a transmission command determined by the message-passing type communication requesting transmission of any transmission data specified by the application on the transmission side; The transmission data length specified by the transmission command is detected by a reception emulation library operating on a reception-side computer before transmission of the transmission data. The specified reception data length and the transmission data length are compared by the reception side emulation library, and (d) the transmission data is stored in an emulation buffer in the reception side computer in accordance with the result of the comparison. Or request to receive the transmission data in the application buffer. (E) issuing a reception command determined by the message-passing type communication by the emulation library on the receiving side; and (e) responding to the transmission command and the reception command issued by the emulation library on the receiving side, and An inter-computer data transmission / reception method in which transmission data is transferred from the transmission-side computer to the emulation buffer or the application buffer by the transmission-side computer and the reception-side computer. (F) when the transmission data is transmitted to the emulation buffer, data corresponding to the reception data length from the emulation buffer is stored in an application buffer designated by the reception instruction;
5. The method according to claim 4, further comprising the step of copying using the emulation library on the receiving side. (G) If the transmission data is transferred into the application buffer in the step (e), it waits for the computer on the transmission side to execute the step (a) for the subsequent transmission data. (H) When step (a) is performed on the subsequent transmission data, the subsequent transmission data and the data of the remaining length of the reception data length requested by the reception command are processed from step (b) onward. The method according to claim 5, further comprising the step of: (I) Before executing the step (a), it is determined whether or not data remaining in the emulation buffer and not transferred to any application buffer remains. 7. The inter-computer data transmission / reception method according to claim 6, further comprising the step of: when the data remains, copying from the buffer to the application within a range not exceeding the reception data length. 8. A computer system having a plurality of computers interconnected by a first communication network, wherein at least some of the computers are interconnected by a second communication network. A communication path used for data transmission / reception between a first application program operating on a first computer among some of the computers and any second application program operating on a second computer To
Determined by a processing routine that operates in accordance with a communication protocol defined for using the first communication network, and (b) processing a connection request for the determined communication path from the first application program by an emulation library. In the processing, it is determined whether or not the second communication network can be used for communication with the second application program. (C) When it is determined that the second communication network can be used, Registering the communication path in the emulation library; and (d) when the first application program issues a data transmission / reception instruction thereafter, the communication path specified by the transmission / reception instruction is registered in the emulation library. (E) that the specified communication path is When it is registered in the library is,
The transmission / reception process requested by the transmission / reception command is executed by the emulation library using the second communication network. (F) When the specified communication path is not registered in the emulation library, A data transmission / reception method, wherein an emulation library requests the processing routine to execute transmission / reception processing requested by the transmission / reception command, and the processing routine executes the transmission / reception processing using the first communication network. 9. The data transmission / reception method according to claim 8, wherein the communication protocol is TCP / IP, and the determination of the communication path includes a process of generating a socket and naming the socket. 10. The data transmission / reception method according to claim 8, wherein the communication using the second communication network is a message passing type communication. 11. A computer having a plurality of computers interconnected by a first communication network, wherein at least some of the computers are connected to the first communication network.
From a first application program operating on a first computer of the above-mentioned some computers, the second computer being connected to a second communication network capable of transferring data at a higher speed than the communication network of the second computer; When the second communication network is available for data transmission / reception with any of the second application programs operating on the above, this is used,
Otherwise, in the computer system using the second communication network, when detecting the presence / absence of data transmitted from another application program addressed to the first application program, through the second communication network The process of detecting data to be transmitted and the process of detecting data transmitted via the first communication network are alternately repeated in a non-block manner. And a transfer data detecting method for transferring the processing to another process running on the first computer. 12. A computer having a plurality of computers interconnected by a first communication network, at least some of which are connected to the first computer.
From a first application program operating on a first computer of the above-mentioned some computers, the second computer being connected to a second communication network capable of transferring data at a higher speed than the communication network of the second computer; When the second communication network is available for data transmission / reception with any of the second application programs operating on the above, this is used,
Otherwise, in the computer system using the second communication network, when detecting the presence / absence of data transmitted from another application program to the first application program, two threads are generated. A data detection method for independently performing detection processing of data transmitted via the second communication network and detection processing of data transmitted via the first communication network on respective threads.