JP2023085797A - Information processing program, information processing device, and information processing method - Google Patents

Abstract

To provide an information processing program, an information processing device, and an information processing method that speed up communication by performing application processing and data transmission in a non-blocking manner.SOLUTION: A server device 1 has buffering means 106 for accumulating events, socket writing means 102 for processing an event, and flag management means 107 for setting a flag exclusively. The socket writing means 102 includes socket writing request means 102a and callback processing means 102b. The flag management means 107 exclusively sets the flag at timing before the socket writing request means 102a starts processing the event, and cancels the flag at timing after the processing of the callback processing means 102b ends. The socket writing request means 102a accepts a call, and processes the events accumulated by the buffering means 106 when the flag is set.SELECTED DRAWING: Figure 2

Description

The present invention relates to an information processing program, an information processing apparatus, and an information processing method.

As a conventional technology, an information processing apparatus has been proposed that transmits data by changing the buffer to be used according to the size of the data (see, for example, Japanese Unexamined Patent Application Publication No. 2002-100002).

A CPU (Central Processing Unit) of the information processing apparatus disclosed in Patent Document 1 parallelizes an application task that occupies an application buffer area and a TCP (Transmission Control Protocol)/IP (Internet Protocol) task that occupies a ring buffer area. execute The application task determines whether the size of the data stored in the application buffer area by the data generation process is equal to or less than a threshold value, and copies the data in the application buffer area to the ring buffer area when the determination result is positive. On the other hand, when the determination result is negative, the right to occupy the application buffer area is temporarily given to the TCP/IP task and the data transmission instruction is issued. The TCP/IP task transmits transmission data on the memory area it occupies in response to the data transmission instruction.

JP 2010-55214 A

However, when the amount of data to be transmitted is small, the information processing apparatus of Patent Document 1 transmits data using a ring buffer and performs application tasks in parallel. However, if the amount of data to be sent is large, the application task will be blocked and will not be processed.

SUMMARY OF THE INVENTION Accordingly, it is an object of the present invention to provide an information processing program, an information processing apparatus, and an information processing method that speed up communication by executing application processing and data transmission in a non-blocking manner.

One aspect of the present invention provides the following information processing program, information processing apparatus, and information processing method in order to achieve the above object.

[1] a computer,
event accumulation means for accumulating events to be processed;
buffering means for accumulating the events;
a processing means for processing the accumulated events;
act as a flag manager that accepts calls and sets flags exclusively,
The processing means includes processing request means for requesting event processing, and callback processing means for receiving a completion notification and executing when the event processing is completed,
The flag management means exclusively sets the flag at a timing before the event processing requesting means starts processing the event, and cancels the flag at the timing after the processing of the callback processing means ends,
The processing request means receives a call at a timing after the event accumulation means finishes accumulating the event in the buffering means and at a timing after the event processing ends for the callback processing means, and responds to the flag of the flag management means. an information processing program for terminating without processing if the flag is not set, and processing the event accumulated by the buffering means if the flag is set.
[2] The buffering means has a first buffering means for accumulating events and a second buffering means for accumulating the events accumulated in the first buffering means,
The processing request means moves and accumulates the event from the first buffering means to the second buffering means when the flag is set, and the second buffering means accumulates the event. The information processing program according to [1], which processes all or part of the event.
[3] One or more buffering means are further provided between the first buffering means and the second buffering means, before the first buffering means, or after the second buffering means. The information processing program according to [2] above.
[4] The information processing program according to [2] or [3], wherein at least one of data block size, number, type, and event holding format is changed in the movement between the buffering means.
[5] The information processing program according to any one of [2] to [4], wherein the number and size of movement events in movement between the buffering means are restricted according to predetermined conditions.
[6] The information processing program according to any one of [1] to [5], wherein the event accumulation operation of the event accumulation means and the processing operation of the processing means are executed asynchronously in the buffering means.
[7] The information processing program according to any one of [1] to [6], wherein the buffering means stores events asynchronously by respective event storage means executed by a plurality of event generators operating in parallel. .
[8] The information processing program according to any one of [1] to [7], wherein the buffering means is a ring buffer.
[9] The information processing program according to [1], wherein the buffering means is a ring buffer that sequentially accumulates the event itself in a memory area.
[10] The buffering means has a two-stage ring buffer structure, the first stage ring buffer stores events of the event storage means operating in parallel, and the second stage ring buffer responds to the processing of the processing means. The information processing program according to the above [2], [6], or [7], which connects and divides the event into a size determined by the above and holds the number of events determined according to the processing means.
[11] The information processing program according to any one of [1], [2], or [6] to [10], wherein the buffering means stores the event in a direct buffer.
[12] The information processing program according to any one of [1], [2], or [6] to [10], wherein the buffering means accumulates the event in a buffer of a buffer pool.
[13] The information according to [10], wherein the buffering means accumulates events in buffers of buffer pools holding different buffer sizes for the first stage ring buffer and the second stage ring buffer. processing program.
[14] The information processing program according to any one of [1] to [13], wherein the processing means finishes event processing after processing all the accumulated events.
[15] event accumulation means for accumulating events to be processed;
buffering means for accumulating the events;
a processing means for processing the accumulated events;
a flag management means for accepting calls and setting flags exclusively,
The processing means includes processing request means for requesting event processing, and callback processing means for receiving a completion notification and executing when the event processing is completed,
The flag management means exclusively sets the flag at a timing before the event processing requesting means starts processing the event, and cancels the flag at the timing after the processing of the callback processing means ends,
The processing request means receives a call at a timing after the event accumulation means finishes accumulating the event in the buffering means and at a timing after the event processing ends for the callback processing means, and responds to the flag of the flag management means. If the flag is not set, the information processing device ends without processing, and if the flag is set, the event accumulated by the buffering means is processed.
[16] a computer;
an event accumulation step for accumulating events to be processed;
a buffering step of accumulating the events;
a processing step of processing the accumulated events;
a flag management step for accepting and exclusively flagging calls;
The processing step includes a processing request step that requests processing of the event, and a callback processing step that is executed upon receiving a completion notification when processing of the event is completed,
The flag management step exclusively sets the flag at a timing before the start of event processing in the event processing request step, and releases the flag at a timing after the processing in the callback processing step ends,
The process request step accepts a call at the timing after the event accumulation in the event accumulation step ends and the event processing in the callback processing step ends, and if the flag is not set, the process is not performed. an information processing method for processing the accumulated event if set.

According to the inventions according to claims 1, 15, and 16, application processing and data transmission can be executed in a non-blocking manner to speed up communication.

FIG. 1 is a schematic diagram showing an example of the configuration of a communication management system according to an embodiment. FIG. 2 is a block diagram illustrating a configuration example of a server device according to the embodiment; FIG. 3 is a schematic diagram for explaining an example of data transmission/reception operations. FIG. 4 is a schematic diagram for explaining an example of data transmission operation. FIG. 5 is a schematic diagram showing a modification of the layer configuration. FIG. 6 is a flow chart for explaining an operation example of the socket write request means. FIG. 7 is a flow chart for explaining an operation example of the callback processing means. FIG. 8 is a flow chart for explaining an operation example of the socket write request means. FIG. 9 is a schematic diagram for explaining another example of the data transmission/reception operation. FIG. 10 is a schematic diagram for explaining another example of the data transmission operation. FIG. 11 is a flow chart for explaining another operation example of the socket write request means. FIG. 12 is a flow chart for explaining another operation example of the callback processing means. FIG. 13 is a flow chart for explaining another operation example of the socket write request means.

[First embodiment]
(Configuration of communication management system)
FIG. 1 is a schematic diagram showing an example of the configuration of a communication management system according to an embodiment.

This communication management system is configured by connecting a server device 1 as an information processing device and terminal devices 2a, 2b, and 2c as clients of the server device 1 so as to be able to communicate with each other via a network. Devices included in the communication management system may be personal computers, game terminals, clouds, and virtual machines. The network may be a LAN, the Internet, or a virtual network.

The server device 1 is a server-type information processing device that operates in response to requests from terminal devices 2a, 2b, and 2c operated by an operator, and has a function for processing information within its main body. It includes electronic components such as a CPU (Central Processing Unit), HDD (Hard Disk Drive), flash memory, volatile memory, and LAN board (wireless/wired). The server device 1 communicates with the terminal devices 2a, 2b, and 2c to transmit and receive data, thereby synchronizing data handled on the terminal devices 2a, 2b, and 2c, and is, for example, a game server. . The server device 1 frequently exchanges small-capacity data when performing a synchronous operation, but is not limited to this. Note that the server apparatus 1 may be configured by a plurality of clusters, and may be configured to execute distributed processing. Alternatively, it may be configured as a virtual machine in a cloud environment.

The terminal devices 2a, 2b, and 2c are terminal-type information processing devices that operate based on programs, and have electronic devices such as CPUs, HDDs, or flash memories that have functions for processing information in their main bodies. Have parts. The terminal devices 2a, 2b, and 2c operate, for example, based on a program such as MMOG (Massively Multiplayer Online Game), sequentially output data to the server device 1 as a result of the operation, and output data from the server device 1 to other devices. It receives data as a result of terminal operations and synchronizes game objects frequently among the terminal devices 2a, 2b, and 2c. Although the terminal devices 2a, 2b, and 2c are depicted as three devices, they may be composed of a single device or two devices, or may be composed of four or more devices, preferably on the order of 1000 units. To provide a configuration capable of communication even when a terminal device is connected.

The network 4 is a communication network capable of high-speed communication, and is, for example, a wired or wireless communication network such as an intranet or a LAN (Local Area Network).

As an example, in the communication management system according to the first embodiment, a multiplayer game is executed in which a plurality of participants play an activity, such as a game, in a common virtual space. The server device 1 and the terminal devices 2a, 2b, and 2c operate to synchronize information (synchronized objects) held as objects in each device as the game progresses. 1 provides a buffer between an application and a NIC (Network Interface Card) to speed up data communication, and controls the operation of data transfer between the application and the NIC. In other words, when a large number of requests to asynchronously write to shared resources (sockets and NICs) are generated by multiple processes and multiple threads, exclusive control is required to serialize data so that data is not mixed. In order to efficiently use the path (especially to improve throughput after the transmission path is congested with data), buffering is performed in a buffer, exclusive control (blocking) is performed on writing to the buffer, and data is written from the buffer. Write to the shared resource is controlled in a lock-free (non-blocking) manner by CAS (Compare and Swap) or the like. Details of the operation will be specifically described in an embodiment.

In addition, terms such as “object” used in the first embodiment are synonymous with synonyms used in, for example, Java (registered trademark), C++, C#, Python, JavaScript (registered trademark), Ruby, and the like. Although used, hereinafter, classes and instantiated classes (instances) may be collectively referred to as "objects."

(Configuration of server device)
FIG. 2 is a block diagram showing a configuration example of the server device 1 according to the first embodiment. Although the implementation in the server device 1 will be described below, the terminal devices 2a, 2b, and 2c may also have the same configuration.

The server device 1 is composed of a CPU (Central Processing Unit) and the like, and includes a control unit 10 that controls each unit and executes various programs, and a storage unit 11 that is composed of a storage medium such as a flash memory and stores information. , a memory 12 configured from a volatile recording medium for temporarily storing information, and a communication section 13 for communicating with the outside via a network.

The control unit 10 functions as an OS execution means 100 (including JVM in the case of Java) by executing an OS (Operating System) 110, and by executing an application 112, an application execution means 103 and an application reading means. 104, functions as application writing means 105, and executes a communication management program 111 as an information processing program to perform socket reading means 101, socket writing means 102, buffering means 106 (receiving buffer 106a and transmitting buffer 106b). ), and functions as flag management means 107 and the like.

The OS executing means 100 (OS kernel) executes the OS 110 and provides each function of the OS 110 . The OS executing means 100 particularly controls the communication unit 13 (NIC) to transmit data to the network and receive data from the network. Note that when JAVA is used, the Java VM is also regarded as part of the OS and is executed by the OS execution means 100 .

The application execution means 103 executes the application 112 as a processing means, provides each function of the application 112, and processes a single thread or a plurality of threads during execution. Typically, each thread communicates through a single or multiple sockets (IP address and port number of the communication target program of the terminal device 2a, 2b, or 2c) respectively corresponding to single or multiple terminal devices. network communication (send/receive).

As a function of the application 112, the application reading unit 104 reads data of the receiving buffer 106a corresponding to the receiving socket (terminal device 2a, 2b, or 2c) for receiving processing of the thread.

The application writing unit 105 writes the data generated as a result of the processing of the thread into the transmission buffer for transmission processing corresponding to the socket (terminal device 2a, 2b, or 2c) to be transmitted. The written data are normally added to the transmission buffer 121b in the order in which they were written. For example, when the game server performs relay processing of synchronization information for synchronization processing of game objects, the application writing means 105 receives synchronization information data from the terminal device 2a, processes the received data in a thread, and outputs the data to the terminal device. Synchronization information data is transmitted to the devices 2b and 2c. Application writing means 105 writes data to two transmission buffers 121b corresponding to two sockets corresponding to respective terminal devices. After adding the data to the transmission buffer 121b, the application writing means 105 calls the socket write request means 102a.

As a function of the OS 110, the socket reading means 101 reads data received by a socket in communication with the network into a reception buffer 106a, which will be described later.

Socket writing means 102 as processing means functions as socket writing request means 102a and callback processing means 102b as processing request means.

6 and 8 are flow charts for explaining an operation example of the socket write request means 102a. Also, FIG. 7 is a flow chart for explaining an operation example of the callback processing means 102b.

As shown in FIG. 6, the socket write requesting means 102a first requests the flag managing means 107 to check the state of the flag managed by the flag managing means 107 (S10). (S11; Yes), set a flag (S12). The socket write requesting means 102a writes the event to the ring buffer 121b immediately before the application writing means 105 finishes writing the event to the ring buffer 121b, and immediately before the completion of the corresponding callback processing means 102b executed after the completion of the socket write requesting means 102a. Called asynchronously from either The call may be a normal method or function call, or it may be signaled to a waiting thread using an OS facility. When the flag is set, the socket write request means 102a next writes the data to be transmitted by communication with the network from the transmission buffer 106b to the socket, and requests the OS execution means 100 to process the event (S13). If the flag managed by the flag management means 107 is already set (S11; No), the process is terminated immediately. For ease of understanding, the flag checking S10/S11 and the flag changing S12 have been described as three separate blocks. When another thread is switched and interrupted, each of the plurality of threads sets a flag (S12), and the own thread executes event processing (S13) as if the flag was set. , the event processing (S13) may be executed multiple times, which is inconvenient. In order to solve this problem, in the present invention, a CAS (Compare and Swap) function provided by the flag management means 107 as described later is used instead of exclusively controlling the execution of the socket writing means 102a by blocking. , flag inspection (S10/S11) and change setting (S12) are executed by a single CPU command, and other threads are devised so that other threads are not executed between the processing of S10, S11, and S12.

Further, as shown in FIG. 8, the socket write request means 102a checks whether or not there is data to be transmitted in the transmission buffer 106b in step S13 (S30). An OS asynchronous transmission request is issued to the OS executing means 100 to request event processing (S31). If there is no data to be transmitted (S30; No), socket write request means 102a requests flag management means 107 to clear the flag (S32).

As shown in FIG. 7, the callback processing means 102b, when the OS execution means 100 completes the processing of the write event requested by the socket write request means 102a (S31 in FIG. 8), the OS execution means 100 Receive a completion notification from (asynchronously) and execute. The network transmission result executed by the OS executing means 100 is received (S20). If the transmission result is normal (S21; Yes), the callback processing means 102b removes the completed transmission from the transmission buffer (S22). Subsequently, the callback processing means 102b requests the flag management means 107 to clear the flag (S23). Subsequently, the callback processing means 102b confirms that there is data to be transmitted in the transmission buffer (S24). If the confirmation result is affirmative (if there is data in the transmission buffer) (S24; Yes), the callback processing means 102b calls the socket write request means 102a (S25). If the confirmation result is negative (S24; No), the callback processing means 102b terminates the process. If the transmission result is abnormal (S21; No), the callback processing means 102b performs exceptional processing (disconnection, etc.) such as disconnection of communication or timeout (S26).

Another implementation of the socket write request means 102a and the callback processing means 102b may be configured as follows. For example, the callback processing unit 102b receives a completion notification when the OS execution unit 100 completes the processing of the write event of the socket write request unit 102a (asynchronously) and receives the executed transmission result. If the transmission result is abnormal, perform exception processing such as disconnection or timeout (disconnection, etc.), and terminate. If the transmission result is normal, delete the completed transmission from the transmission buffer. Subsequently, the callback processing means 102b confirms that the transmission target data exists in the transmission buffer, and if the confirmation result is affirmative, calls the socket write request means 102a. If the confirmation result is negative, the flag management means 107 is requested to cancel the flag, and the process ends.

The buffering means 106 prepares two types of buffer areas in the memory 12, a receive buffer 106a and a transmit buffer 106b, both of which provide targets for reading and writing and manage data to be read and written. By using the buffer, reading and writing to the buffer can be performed asynchronously. The receiving buffer 106 a is written by the socket reading means 101 and read by the application reading means 104 . The transmission buffer 106b is written by the application writing means 105 and read by the socket writing means 102. FIG. The buffering means 106 (106a and 106b) reads and writes data in a non-blocking manner. It is inefficient for the CPU to allocate the memory required for the buffer each time it is executed. It is common to manage memory independently using a buffer pool, reuse and reuse allocated memory blocks, and improve processing efficiency during execution. It is also common to logically configure a ring buffer by combining these memory chunks. Here, the case where the ring buffer 121 (a receiving ring buffer 121a as the receiving buffer 106a and a transmitting ring buffer 121b as the transmitting buffer 106b), which is a kind of buffer pool, is used as the buffer area will be described, but the ring buffer is not necessarily used. There is no need, any buffer that can logically provide an infinite length buffer can be used. Preferably, a direct buffer suitable for processing in the OS kernel is created in a memory area outside the heap area, enabling high-speed input/output. temporary storage area.

Since the direct buffer exists in the real memory space, data processing on the direct buffer in the execution of the OS process requires less internal memory than data processing on the normal non-direct buffer that exists in the virtual memory space. It is known that the number of operations can be reduced and the processing time can be shortened. It is known that the direct buffer requires more OS processing time to allocate and release memory than the non-direct buffer. Particularly in the case of direct buffers, it is not appropriate for applications to frequently allocate and release memory, and it is desirable to reuse pre-allocated memory by utilizing buffer pools, which will be described later. Direct buffers are suitable for processing by the OS. Therefore, it is also known that the use of direct buffers for normal processing is inappropriate. It is preferable not to overuse the direct buffer, but to limit its use to specialized storage of data for which processing requests are made to the OS. In addition, the direct buffer is a shared resource that is used not only by the application concerned, but also by other applications running on the information device. Appropriate usage savings are desirable. Although the preferred method of use has been shown above as an example with the first embodiment in mind, the method of use of the present invention is not limited.

Next, a buffer pool is a system that collects a certain amount of free space from the main memory and stores it in multiple memory blocks when an application starts, etc., in order to quickly and dynamically allocate the necessary memory space during application execution. shall be secured as The buffer pool is implemented as an application without relying on the OS for memory management. The memory that is no longer needed after being used is returned to the buffer pool and reused (memory release). Various implementations of the buffer pool are known. Since a memory block is usually a large size such as a page size, here, it is divided in advance into one or more standardized size memory chunks that are easy to use for applications, and registered in the buffer pool. The chunk size is usually adjusted to be one power of two of the page size. A memory block can be divided without waste by setting it to 1/2 by a power of 2. In addition, memory fragmentation can be avoided by reusing memory blocks of standardized chunk size. In addition, managing memory as a buffer pool by an application does not generate overhead such as calling the OS for individual memory allocation and release, compared to the case of using memory allocation and release to the OS each time it is necessary. It is known that memory allocation/release processing is made more efficient. When adopting a buffer pool, various design policies can be considered for the size, type, and number of memory chunks registered in the pool, depending on the application. Although the preferred method of use has been shown above as an example with the first embodiment in mind, the method of use of the present invention is not limited.

In the first embodiment, when a buffer pool is used, a chunk size standardized to a size suitable for OS processing is used as the size of the memory chunk (for example, the page size is the memory block as it is or half of it). etc.), and as the type of memory, a direct buffer memory suitable for OS processing is used. By cramming the event data into a large size (e.g., page size) memory chunk that is suitable for OS processing, the OS is able to handle the event data rather than holding each very small size event data in a separate chunk. As an asynchronous transmission function to be provided, AsynchronousSocketChannel. It effectively reduces the number of memory chunks specified for gathering writes of write( ) and improves the processing efficiency in the OS. It is known that when the OS processes the same number of bytes of data, the smaller the number of chunks stored, the faster the internal processing. For example, the chunk size adopts a single size such as the page size or half thereof, more specifically 1 KB or 2 KB. As for the type of memory block to be secured for OS processing, using a direct buffer suitable for OS processing instead of a normal memory (non-direct buffer) secured in the heap will further improve the processing efficiency of the OS. is good. Adopting a direct buffer is a technology that can be used both in combination with a buffer pool and in cases where memory is allocated and released each time without using the buffer pool. technology. Although the preferred method of use has been shown above as an example with the first embodiment in mind, the method of use of the present invention is not limited.

The flag management means 107 manages flags atomically by means of, for example, CAS (Compare and Swap). Here, atomic refers to an indivisible operation. Specifically, one instruction compares the contents of a certain memory location with a specified value, and if they are equal, stores another specified value in that memory location. Refers to a special CPU instruction to perform. The flag management unit 107 sets a flag exclusively at the timing when the OS execution unit 100 starts event processing in response to a request from the socket write request unit 102a (FIG. 6, S12), and sets a flag at the timing of completion of event processing (callback The flag is cleared in the process of the processing means 102b (S23 in FIG. 7). Incidentally, even though the flag is cleared in S32 of FIG. 8, the flag is raised at the timing of starting the event processing, but this is (exception) processing when there is no data for the event processing. As described above, since the operation shown in FIG. 6 is performed, the socket write request means 102a and the callback processing means 102b are limited to one socket write request means 102a and one callback processing means 102b by the function of the flag management means 107. Concurrency is controlled to ensure consistency of write operations to sockets. If the flagged socket write request means 102a or the callback processing means 102b corresponding to the socket write request means 102a is in process, calling the second and subsequent socket write request means 102a Since the flag itself cannot be set while the flag is set, the process is interrupted and ends without writing to the OS execution means 100 (S11 in FIG. 6; No). For this reason, the socket write request means 102a cannot necessarily execute an asynchronous transmission call to the OS for its own event, but executes it in a non-blocking manner and ends processing without waiting until the event can be transmitted. Even if the socket write request means 102a itself cannot execute the asynchronous send call, the socket write means 102 (socket write request means 102a or callback processing means 102b) in execution will execute the asynchronous send call in the near future. execute That is, for an event for which processing by the socket write request means 102a has ended without the asynchronous transmission call being executed, the flag has already been set depending on the timing at which the event was accumulated in the first buffer _121b1 . Socket write request means 102a called by the socket write request means 102a itself or the callback processing means 102b corresponding to the socket write request means 102a which is exclusively executing after the socket write request means 102a when the transmission buffer is not empty. makes an asynchronous send call. As described above, the operation of flags enclosed by dotted lines (steps S10, S11, and S12 for status confirmation and setting) must be executed atomically so as not to be affected by interrupts by other threads in a multithread environment. , and the (Compare and Swap) function provided by the flag management means 107 is used.

The storage unit 11 stores an OS 110, a communication management program 111, an application 112, and the like, which causes the control unit 10 to operate as each of the means 100 to 107 described above. It should be noted that the objects for functioning as the means 100 to 107 may be performed by appropriately replacing the OS 110, the communication management program 111, and the application 112. FIG. Also, a relational database, a file system, or the like is used for the storage unit. For speeding up, an in-memory database such as Redis may be used or used together.

The memory 12 is controlled by buffering means 106 and other means (not shown) to temporarily store information.

The terminal devices 2a, 2b, and 2c have the same configuration as that of the server device 1, but also an operation unit and a display unit. A description of the parts that have the same configuration as the server device 1 will be omitted.

(Operation of information processing device)
Next, the operation of the first embodiment will be described separately for (1) basic operation and (2) data transmission operation.

(1) Basic Operation As an example, multiple users participate in the same virtual space in order to synchronize multiple game objects and share the experience (game play) in the same virtual space (room). The game progresses in each of the terminal devices 2a, 2b, and 2c, and the server device 1 does not progress the game and only performs the synchronous operation of the objects, or the server device 1 also progresses the game. good.

Upon receiving a room participation request, the participant management means (not shown) of the server device 1 sends a participation request associated with the room ID in the storage unit 11 to the participant along with the user ID, user name, socket ID, participation date and time. recorded in the user management information.

During game play, the terminal devices 2a, 2b, and 2c sequentially generate, update, and delete a plurality of objects (characters, weapons, items, etc.) as applications are executed. When proceeding with the game, the server device 1 accepts and processes object operation requests from the terminal devices 2a, 2b, and 2c, and notifies the terminal devices 2a, 2b, and 2c of the processing results so that the objects can be processed. Synchronize. When the game is not progressing, the server device 1 performs a relay operation for synchronizing the objects in the terminal devices 2a, 2b, and 2c. In the relay operation, the server device 1 transmits and receives a plurality of objects. In any case, the server device receives from the terminal devices 2a, 2b, and 2c information on the operations of the plurality of objects operated by each of them, and transmits information on the operation of the plurality of objects corresponding to the terminal devices to be synchronized. . Although the size of individual object operation information is small, frequent data synchronization (at least about 20 to 30 times per second) is required to achieve smooth object drawing in each of the terminal devices 2a, 2b, and 2c. If there are many objects to be synchronized in a sophisticated game, or if there are many terminal devices to be synchronized such as MMOG, the number of sending and receiving packets for synchronization processed by the server will be huge like streaming sending and receiving due to combinatorial explosion. sell. In recent years, the speed of CPU and memory has increased significantly, but network bandwidth, throughput and latency with individual terminals have physical and distance restrictions, and there are trends such as mobile usage patterns, so the speed increase is more gradual. is. Therefore, network transmission/reception tends to become a bottleneck in server processing. The present invention realizes efficient use of network transmission, a method of using a NIC level that is always processing and has as little idle time as possible, and an implementation using Java, in particular, that improves socket utilization during transmission. The details of the transmission/reception operation of the server device 1 will be described below.

FIG. 3 is a schematic diagram for explaining an example of data transmission/reception operations.

First, when the server device 1 receives data from the network 4, the socket reading means 101 reads data from the source 131 of the network 4 via the channel 130, and the socket reading means 101 reads the socket corresponding to the channel (with a certain IP address corresponding to the receiving terminal device). port) and writes it to the position of the write pointer in the reception ring buffer 121a. The data is added to receive ring buffer 121a. Separate buffers are prepared for each channel or socket. A channel/socket is used for both transmission and reception, and one channel/socket is prepared for each corresponding terminal device (a specific program that becomes a communication partner of the terminal device). One application buffer is shown in the drawing, but in practice, it is managed separately for transmission and reception. The ring buffer 121 is managed as one pool for all channels, and although one is shown in the figure, the ring buffer 121 manages independent pointers for each channel and for transmission and reception separately. , and separate reception ring buffer 121a and transmission ring buffer 121b for each channel.

Next, the application reading means 104 reads the data of the reception ring buffer 121 a corresponding to the receiving terminal device (channel or socket) from the position of the read pointer and writes it to the application buffer 120 . Data is retrieved from the receive ring buffer 121a and removed from the receive ring buffer 121a. Here, the application buffer 120 is independently managed by the application and not provided by the buffering means 106 . The app buffer is provided by another buffering means. For example, OS functions (normal memory allocation, memory release) may provide app buffers. In order to reuse the memory and improve the efficiency of memory management, another buffering means may be configured so as to provide a function equivalent to the buffering means 106 to provide an application buffer.

The application execution unit 103 reads data from the application buffer 120 and processes it in a thread.

Also, when transmitting data processed by the thread of the application execution unit 103 to the network 4 , the application execution unit 103 writes the data processed by the thread into the application buffer 120 .

Next, the application writing means 105 writes the write pointer of the transmission ring buffer 121b corresponding to the destination terminal device, more precisely, the channel or socket, according to the destination terminal device for which the data in the application buffer 120 is intended. write to the position of As a result, the data is added to the transmission ring buffer 121b. After the data is written, the write pointer is advanced to move to the position next to the write end position. When the application writing means 105 writes data next time, the write pointer after movement is used, so the data to be written next time is added after the data written this time. On the other hand, the data in the application buffer 120 becomes unnecessary after being copied to the transmission ring buffer 121, and the application executing means 103 can reuse this buffer area. The transmission ring buffer 121b is prepared for each channel or socket.

Next, the socket writing means 102 reads the data from the position of the read pointer of the transmission ring buffer 121b to the position just before the position of the write pointer, and writes it to the channel 130 by the socket. Data is transmitted to source 131 via channel 130 . The read pointer advances by the number of bytes successfully transmitted and moves to the location next to the data that has been successfully transmitted. At this time, the data is taken out from the transmission ring buffer 121b, and the OS execution means 100 performs transmission processing as a transmission object, and the data that has been transmitted (all or part of the data taken out) is excluded from the transmission ring buffer 121b. be done. Data for which transmission has not been completed continues to remain in the transmission ring buffer 121b. Here, all the data accumulated in the transmission ring buffer 121b is transmitted at once, but if the data accumulated in the transmission ring buffer 121b becomes huge, the limitation of the OS transmission function call is considered. For example, instead of reading all at once, only a part of the data may be read and transmitted.

As described above, the ring buffer 121 is a ring buffer that sequentially writes (accumulates) data (events) in a memory area (or a virtually continuous memory area) and directly stores read data. The data to be managed is arranged and stored (directly storing the data to be managed) in the memory area in order. This ring buffer 121 does not store (indirectly store data to be managed) pointers to the stored memory as write or read pointers in a memory area (or virtually continuous memory area). . In addition, since the ring buffer 121 loses the boundaries of the write units of data (events) by writing, if it is necessary to process data (events), boundary information must be managed separately. In the first embodiment, since data processing (event processing) is network transmission by the OS kernel, it is transmitted as a byte stream regardless of data (event) boundaries, so data (event) boundaries are not managed. You don't have to. Also, in cases where the same effect as in the first embodiment can be obtained, the use of other virtual ring buffers is not barred.

A case in which data processed by the thread of the application execution means 103 is transmitted from the OS execution means 100 to the network 4 will be described in detail below.

(2) Data Transmission Operation FIG. 4 is a schematic diagram for explaining an example of data transmission operation.

The application execution means 103, for example, processes data by a plurality of threads 1 and 2, and transmits data A and data B as processing results to the same terminal device (more precisely, the same socket or channel). Then, the application writing means 105 writes to the transmission ring buffer 121b corresponding to the socket for communication to the destination terminal. In order to transmit to multiple channels, each means of the present invention is required for each channel. It is assumed that processing of threads 1 and 2 occurs asynchronously under a multithread environment. Application writing means 105 performs blocking control so that data A and data B are written at maximum one data per channel, and application writing means 105 writes data A of thread 1 to transmission ring buffer 121b. During this time, the write processing of data B of thread 2 is made to wait. Similarly, while the application writing means 105 is writing the data B of the thread 2 to the transmission ring buffer 121b, the thread 1 waits for the data C writing process. Writing to the transmission ring buffer 121b starts from the position of the write pointer, and when writing ends, the write pointer is moved next to the write end position. For the sake of simplicity of explanation, if a non-blocking buffer is adopted as the transmission buffer 106b that performs blocking control so that write operations between threads are not mixed in the transmission ring buffer 121b, then the application writing means 105 work efficiently. In other words, the write pointer and read pointer of the transmission ring buffer 121b are assigned to a thread for writing (application writing means 105) and a thread for reading (socket), of which at most one is active at a given time. Since the writing means 102) operates exclusively, writing (application writing means 105) and reading (socket writing means 102) can be performed non-blocking and asynchronously.

Next, the socket write request means 102a refers to the CAS flag of the flag management means 107. If the flag is not set, the socket write request means 102a sets the flag and calls the OS system call (for example, AsynchronousSocketChannel.write() of JAVA). , the data accumulated in the transmission ring buffer 121b (the data from the read pointer to the point immediately before the write pointer at the time of calling) is transmitted. At this point, only data A is stored in the transmission ring buffer 121b. The socket write request means 102a requests the OS execution means 100 (OS kernel) to write the data A in the transmission ring buffer 121, and terminates (1).

Next, the OS kernel 100 determines an appropriate size for the data A (the size is, for example, a network-dependent maximum packet size MTU (Maximum Transmission Unit, MTU is 1500 bytes for Ethernet) and various protocol headers. Typically, in the case of TCP/IP on Ethernet, it is divided into MSS (Maximum Segment Size) 1460 bytes obtained by subtracting 20 bytes of TCP header and 20 bytes of IP header) and transmitted to network 4 as data A1 and A2. do. If data B is written from the application writing means 105 to the transmission ring buffer 121b during the event processing of the OS kernel 100, the transmission ring buffer 121b will not be able to store the data B even while the OS kernel 100 is reading. is accumulated non-blocking. Application writing means 105 continues to call socket write request means 102a, but socket write request means 102a is processing data A and the CAS flag of flag management means 107 is set, so socket write request means 102a The process ends immediately in a non-blocking manner without transmitting data B (2). Thread 2 can execute the next process without waiting for completion of the relatively long network transmission process (event process of OS kernel 100). At this point, data B is added to the transmission ring buffer 121b, and data A and data B are present.

Next, when the transmission of data A is completed, the OS kernel 100 activates the callback processing means 102b and notifies the transmission completion. The callback processing means 102b confirms the number of bytes that have been transmitted. In this case, the transmission of the entire data A has been completed. Exclude from ring buffer 121b. Next, the callback processing means 102b clears the CAS flag of the flag management means 107. FIG. At this point, the transmission ring buffer 121b has data A removed and only data B exists. Next, callback processing means 102b determines whether there is still data to be transmitted in transmission ring buffer 121b (if the read pointer and write pointer match, there is no data to be transmitted). If there is data to be sent, the socket write request means 102a is called. If there is no data to send, terminate. In this case, since the data B already exists in the transmission ring buffer 121b, the socket write request means 102a is called (3).

Next, the socket write request means 102a requests the flag management means 107 to refer to the CAS flag. Since the flag is not set, the flag is set and an OS system call (AsynchronousSocketChannel.write()) is called. and transmits the data accumulated in the transmission ring buffer 121b (the data from the read pointer to the point immediately before the write pointer at the time of calling). At this point, only data B is stored in the transmission ring buffer 121b. The socket write request means 102a requests the OS kernel 100 to write the data B in the transmission ring buffer 121b, and terminates.

Next, the OS kernel 100 divides the data B into appropriate sizes and transmits them to the network 4 as data B1, B2, and B3. During event processing of the OS kernel 100, when data C is written from the application writing means 105 to the transmission ring buffer 121b, the transmission ring buffer 121b accumulates the data C in a non-blocking manner and calls the socket write request means 102a. The write means 102 is processing the data B requested to the OS by the immediately preceding socket write request means 102a, and since the CAS flag of the flag management means 107 is set, the socket write request means 102a does not send the data C. Terminate immediately without requesting the OS kernel 100 (4). Similarly, when data D is written from the application writing means 105 to the ring buffer 121, the ring buffer 121 accumulates the data D in a non-blocking manner and calls the socket write request means 102a. Since the CAS flag of the flag management means 107 is set during the processing of B, the socket write request means 102a immediately terminates without transmitting the data D (5). At this point, data B, data C, and data D are stored in order in the transmission ring buffer 121b.

Next, when the transmission of data B is completed, the OS kernel 100 activates the callback processing means 102b and notifies the transmission completion. The callback processing means 102b first confirms that the number of transmission completion bytes is the entire data B, and then sets the read pointer of the transmission ring buffer 121b to the position next to the data B (in this case, the beginning of the data C). Moving. At this time, the transmission ring buffer 121b stores data C and data D with data B excluded. The callback processing means 102b next clears the CAS flag of the flag management means 107, and then confirms that the transmission ring buffer 121b is not empty (in this case, data C and data D are accumulated). After confirmation, the socket write request means 102a is called.

Next, the socket write request means 102a refers to the CAS flag of the flag management means 107. Since the flag is not set, the socket write request means 102a sets the flag, calls the OS system call (AsynchronousSocketChannel.write()), and The data C and data D in the buffer 121b are written to the OS kernel 100 (6).

Next, the OS kernel 100 divides the data C and data D into appropriate sizes and transmits them to the network 4 as data C1, C2, C3, . When data E is written from the application writing means 105 to the transmission ring buffer 121b during event processing of the OS kernel 100, the transmission ring buffer 121b accumulates the data E in a non-blocking manner. Since the CAS flag of the management means 107 is set, the socket write request means 102a terminates without transmitting the data E (7). Similarly, when data F is written from application writing means 105 to transmission ring buffer 121b, transmission ring buffer 121b accumulates data F in a non-blocking manner (8). At this point, the transmission ring buffer 121b has accumulated data C, data D, data E, and data F. FIG.

Next, when the transmission of data C is completed, the OS kernel 100 happens to activate the callback processing means 102b without executing the processing of D this time, and notifies the completion of transmission. In general, the OS system call (AsynchronousSocketChannel.write()) does not always guarantee to complete the transmission of all requested data. Only part of the requested data may be sent for reasons such as the OS or network load. Therefore, confirmation of the number of bytes that have been transmitted is essential. In addition, this system call provides a gathering write function for specifying a plurality of buffers (memory chunks) and collectively sending them with one system call. Therefore, even if C and D are not a continuous single memory chunk, but two or more memory chunks, a transmission request can be made with one system call. In this example, the end of transmission of the entire data C was accidentally notified, but for the OS kernel 100, data C and data D are aggregated continuous data to be transmitted, and it is not possible to distinguish whether they are different data. Therefore, it is purely accidental that the data C is completely sent. During the transmission of the data C, there is a case where the transmission is terminated with a part of the data C left. Since multiple memory chunks can be specified in aggregated transmission, C and D may be specified by dividing them into multiple memory chunks, or C and D may be specified in a single memory chunk. Alternatively, it may be divided into a plurality of memory chunks in which C and D partially intersect (for example, three chunks such as the first half of C, the second half of C, the first half of D, and the second half of D). . On the other hand, the aggregate transmission of the OS tries to transmit the specified chunks in order, but depending on the circumstances of the OS, all the specified chunks may be sent, or only some chunks of the specified chunks may be sent. Sometimes. Here, the partial chunk may be the entire partial chunk of a plurality of chunks, or the last chunk may be only the first part of the chunk and may be left unsent. Not all bytes included in the chunk specified for transmission will be successfully transmitted, so the number of bytes successfully transmitted is checked in the callback routine, and the chunks left unsent or part of the chunks will be the target of the next aggregated transmission. should be (For example, transmission of C1 and C2 is completed and C3 is left, or transmission of the first half of C3 in addition to C1 and C2 is completed and the latter half of C3 is left.) First, the number of bytes that have been transmitted is confirmed. In this case, only data C has been completely transmitted. ) At this point, the transmission ring buffer 121b has data C removed, but since data E and data F are added during data C transmission processing, the transmission ring buffer 121b stores data D, It stores data E and data F. Next, the callback processing means 102b clears the CAS flag of the flag management means 107. In this case, the callback processing means 102b sends data to the transmission ring buffer 121b. data (in this case, data D, data E, and data F), the socket write request means 102a is called.

Next, the socket write request means 102a refers to the CAS flag of the flag management means 107. Since the flag is not set, the socket write request means 102a sets the flag, calls the OS system call (AsynchronousSocketChannel.write()), and A write request is issued to the OS kernel 100 for all the data DEF in the buffer 121b (9).

Next, the OS kernel 100 divides the data DEF into appropriate sizes and transmits them to the network 4 as data D1, D2, .

Next, when the OS kernel 100 happens to complete the transmission of only the data D, it activates the callback processing means 102b and notifies the transmission completion. When the callback processing means 102b confirms the number of transmitted bytes, it happens that only the data D has been transmitted. Since the flag is cleared and the transmission ring buffer is not empty, the socket write request means 102a is called.

Next, the socket write request means 102a refers to the CAS flag of the flag management means 107. Since the flag is not set, the socket write request means 102a sets the flag, calls the OS system call (AsynchronousSocketChannel.write()), and writes to the ring buffer. The OS kernel 100 is requested to write the data EF of 121 (10).

Next, the OS kernel 100 divides the data EF into appropriate sizes and transmits them to the network 4 as data E, F1 and F2.

Next, when the OS kernel 100 transmits the data E and F, it activates the callback processing means 102b and notifies the completion of transmission. The callback processing means 102b confirms the number of transmission completed bytes, moves the read pointer of the transmission ring buffer 121b to the position next to the data F, and clears the CAS flag of the flag management means 107. FIG. The callback processing means 102b terminates the processing when the transmission ring buffer 121b becomes empty (the read pointer and the write pointer match).

In the above examples, for ease of explanation, the data A to F are illustrated as large pieces of data each transmitted as one or more network packets. When the game server transmits and receives object synchronization information like streaming, the size of each piece of data is very small compared to the network transmission packet size. Sent as a send packet. Therefore, the non-blocking socket writing means by CAS has a significantly smaller overhead than the case of using the OS lock function, and also puts a plurality of data together in a continuous block, or a plurality of data. By collectively sending the data with one OS transmission request, the transmission channel can be efficiently operated without interruption, which is particularly useful in a mode of use such as streaming.

(Effect of the first embodiment)
According to the above embodiment, the transmission ring buffer 121b is provided between the application writing means 105 and the socket writing means 102, and the transmission ring buffer 121b accumulates the data written by the application writing means 105 in a non-blocking manner. , the write operation of the socket write request means 102a is executed according to the CAS flag, the CAS flag is managed by the flag management means 107, the flag is set when the socket write request means 102a starts writing, and the OS execution means 100 The flag is cleared by the callback processing means 102b upon receiving the event processing completion notification, so that the writing operation of the application writing means 105 does not directly affect the transmission event processing operation of the OS execution means 100. (The waiting time for the application writing means 105 and the OS execution means 100 to correspond to each other is eliminated, and the number of calls for each is reduced.), application processing and data transmission are executed in a non-blocking manner for high-speed communication. can be In particular, transmission processing to the network, which takes a relatively long time, is performed with a short wait time (latency), continuous processing as much as possible, and non-blocking, giving priority to network transmission processing, increasing transmission throughput, and asynchronous transmission ( Application processing can be executed during the waiting time for NIO) processing.

In addition, the OS resources (total amount of memory, number of threads, number of OS function calls) consumed by the application can be reduced, and high-speed processing can be realized. Also, when operating with a rental server or cloud service, it can be operated with more compact server specifications, which reduces operating costs.

(Second embodiment)
The second embodiment differs from the first embodiment in that there are two types of intermediate buffers as transmission buffers and that the application writing means 105 is non-blocking during multithreading. The application writing means 105 can perform non-blocking parallel processing, and application processing efficiency is improved compared to the first embodiment. The description of the configuration and operation common to those of the first embodiment may be omitted. First, the configuration of the communication management system and the configuration of the server device in the second embodiment are the same as those shown in FIGS. 1 and 2 shown in the first embodiment, respectively, so descriptions thereof will be omitted. Operations and functions specific to the first embodiment in the descriptions of FIGS. 1 and 2 will be described below, including differences from the first embodiment.

As shown in FIGS. 9 and 10, compared with the first embodiment (FIGS. 3 and 4), the ring buffer 121 (see FIG. 3) is intermediate in the second embodiment. In that the buffering means 106 is replaced with the buffer 121B (see FIG. 9), the buffering means 106 stores not only the ring buffer 121b (see FIG. 4) but also the first buffer 121b1 and the second buffer 121b as transmission buffers in _the memory 12. ₂ (see FIG. 10) is different from the first embodiment.

As shown in FIG. 10, the first buffer _{121b_1} accepts writing of an event generated as a result of the processing of the thread 103 by the application writing means 105, and the second buffer _{121b_2} accepts the socket writing means 102a. accepts writing of a set of data written for each thread to the first buffer _121b1 . When events are held in standardized memory chunks, the first buffer _121b1 , as an example, considers a standard event size and stores events in chunks so that chunks are not often left unused. In addition, the chunk size is calculated and designed using various existing optimization algorithms, etc. Here, the event is held in a standardized chunk of 256 bytes (if the event size is larger than 256 bytes, it is held in multiple chunks). It is assumed that multiple items are retained. Chunks are managed by a buffer pool, and assuming that the buffer pool is shared by a plurality of channels, if 4096 chunks are prepared as an initial value, the total is 1 MB. If the buffer pool runs short, it is desirable to have a configuration that can be expanded by allocating additional memory chunks. Also, sharing a buffer pool with multiple channels means that different channels and different sockets are used for different destinations, so the present invention will focus on the operation of a single channel, but the same applies to other channels as well. , but if the buffer pools that provide memory chunks to the respective buffering means are centrally managed, compared to the case where each channel individually holds a buffer pool, Since duplication of memory allocation is eliminated and memory can be accommodated between channels, the total memory allocated as a buffer pool can be saved. On the other hand, the second buffer _121b2 is used for event processing in the OS. As an example, the second buffer _121b2 holds transmission data to be processed in normalized chunks of 2048 bytes, considering the page size, which is the preferred data processing size of the OS. Assuming that chunks are managed by a buffer pool and that the buffer pool is shared by a plurality of channels, if 4096 chunks are prepared as an initial value, the total is 8 MB. As with the buffer pool of the first buffer _121b1 , if the buffer pool runs short, it is desirable to have a configuration that can be expanded by allocating additional memory chunks. The chunk capacity and the number of chunks of the first buffer 121b- ₁ and the second buffer 121b- ₂ are appropriately set according to the communication environment and system specifications, and are not limited to the values shown as examples. . However, since the memory chunks of the buffer pool are used by dividing a large memory that has been collectively obtained in advance, the size of the memory chunks is the page size of the server device 1, or 2 of the page size, considering memory boundaries. It is desirable for memory system efficiency to choose from 1/n powers of , and an arbitrary number of bytes such as 50 bytes or 100 bytes should not be chosen. Also, if a direct buffer suitable for processing in the OS is used as the second buffer, the transmission processing efficiency in the OS will be improved.

Also, as shown in FIGS. 11, 12, and 13, the second embodiment differs from the first embodiment (FIGS. 6, 7, and 9) in the usage of the flag management means 107. , socket writing means 102 as processing means, socket writing request means 102a and callback processing means 102b as processing request means operate differently from the same means in the first embodiment. differ in form and composition. The operations of the socket write request means 102a and the callback processing means 102b will be described below. In the second embodiment, since the application writing means 105 is capable of non-blocking parallel processing, this change of the flag management means 107 is limited to the period when the application writing means 105 is continuously and frequently executed. , the application writing means 105 does not call the socket write request means, but writes the event to the intermediate buffer 121B. Instead, while the application writing means 105 is being executed continuously and frequently, the callback processing means of the already executing socket writing means 102 continues until there are no more events held by the intermediate buffer 121B. Call the socket writer. This shortens the average processing speed of the application writing means 105 and improves the efficiency of parallel processing of the threads 103 of the application. The first embodiment also applies the usage of the flag management means 107 (the operation of the socket write request means 102a and the callback processing means 102b) emphasizing the parallel operation efficiency of the transmission threads of the application shown in the second embodiment. Conversely, in the second embodiment as well, the usage of the flag management means 107 emphasizing the transmission processing efficiency of the OS shown in the first embodiment (socket write request means 102a and callback processing action of means 102b) can also be applied. Also, on the other hand, the flag management method is not limited to these two types of methods, and other methods for performing event addition and event processing in a non-blocking and asynchronous manner may be used.

11 and 13 are flow charts for explaining an operation example of the socket write request means 102a. Also, FIG. 12 is a flow chart for explaining an operation example of the callback processing means 102b.

First, as shown in FIG. 11, the socket write request unit 102a confirms the caller (S40), and if the caller is the application write unit 105 (call after adding the event to the first buffer) (S40 Yes), the flag management means 107 is requested to check the state of the flag managed by the flag management means 107 (S41), and if the flag is cleared (S42; Yes), the flag is set (S43). Socket write request means 102a writes an event immediately before application write means 105 writes an event to ring buffer 121b and immediately before termination of corresponding callback processing means 102b executed after socket write request means 102a ends. is called asynchronously from either The call may be a normal method or function call, or it may be signaled to a waiting thread using an OS facility. Only in the former case, the flag management means is used to determine whether or not it is possible to request event processing to the OS execution means. In the latter case, since the event processing is being executed by the OS execution means one or more times after the flag has already been set, the OS execution means is requested to process the event without setting the flag again. . The simplest way to notify the caller is to include the caller identifier in the call parameters, but any other method is acceptable. If the flag is set in the former case, then the socket write request means 102a requests the OS execution means 100 to process the event (S44). On the other hand, in the former case, if the flag managed by the flag management means 107 is already set (S42; No), the process is terminated immediately. In the latter case, that is, when the calling source is not the application writing unit 105 but the callback processing unit 102b (S40; No), the socket write request unit 102a responds to the execution of the callback processing unit 102b. Since the flag has already been set when the socket write request means 102a was executed immediately before, the OS execution means 100 is requested to process the event regardless of the state of the flag (S44). As described above, similarly to FIG. 6, operations of flags enclosed by dotted lines (status confirmation and setting S41, S42, and S43 are atomically executed so as not to be affected by interrupts by other threads under a multithread environment. Therefore, the (Compare and Swap) function provided by the flag management means 107 is used.

13 shows the operation of the OS executing means 100. As shown in FIG. In step S44 (FIG. 11), the socket write request means 102a checks whether there is data to be transmitted in the first buffer _121b1 (S60), and if there is data to be transmitted (S60; Yes), the first If necessary, the events on the buffer 121b- ₁ in the buffer 121b-1 are moved to the second buffer 121b- ₂ (S61). If the data is simply moved, this step can be omitted and the OS asynchronous send call S63 can be executed immediately for the data in the first buffer. Since it is a move operation, some kind of performance improvement is expected in the move operation, such as changing the memory type of the buffer, changing the memory size of the buffer, changing the arrangement of data in the buffer, the number of moves (number of move events, or , the number of bytes moved), etc., and copies the event held in the memory chunk of the first buffer to the newly allocated memory chunk of the second buffer, and after the copy of the first buffer is completed Release unnecessary memory chunks.

It is more efficient to allocate and release memory chunks held by buffers using a buffer pool. The various variations below assume a buffer pool and are described with buffers using standardized size memory chunks in mind, but the present invention is not limited to all or only some of these operations. However, even if the memory chunks are normally deallocated each time, and even if the size of the chunks varies, it does not exclude the following variations and other useful operations.

First, as for the type of memory chunk, the OS uses the second buffer for processing (S63) as will be described later, so it is preferable to use a direct buffer suitable for the processing of the OS.

Next, consider the buffer size and data placement. The OS is more efficient to process the same size data in one large chunk of memory than to process many small chunks. Therefore, it is preferable to reduce the number of memory chunks processed by the OS by preparing a large memory chunk and sequentially arranging a plurality of events in one memory chunk.

Next, consider movement. All the events held in the first buffer 121b- ₁ may be simply moved to the second buffer 121b- ₂ at the timing of the transfer. However, considering that the second buffer uses the direct buffer used for OS processing, and that there is an upper limit to the number of memory chunks and the total number of bytes that can be processed at once by the OS processing request, the usage of the direct buffer is To do this, the number of moving events should be controlled so that the memory chunks held by the second receiving buffer are less than or equal to the size appropriate for the OS processing requirements. For example, an upper limit such as 32 is set for the number of direct buffer memory chunks held by the second buffer. If you are holding memory chunks (a number close to 32 memory chunks in this example), stop moving at an upper bound (in this example a predetermined upper limit, e.g. 32 or 33), or , if the upper limit is already exceeded, no movement is performed (0 movement is performed). In this way, by setting a limit such as an upper limit on the number of memory chunks held by the second buffer _121b2 , an event delayed due to a communication failure or the like is accumulated in the first buffer _121b1 and shared by the entire server apparatus 1. It does not bloat the second buffer _121b2 , which uses the direct buffer resource to be used. Conversely, in a healthy state where the second buffer holds few chunks, all events in the first buffer _121b1 can be moved.

Movement of events from the first buffer _121b1 to the second buffer _121b2 is performed by changing the type of memory chunk, changing the size of the memory chunk, changing the data arrangement in the memory chunk, and controlling the number of events to be moved. Alternatively, all or part of other measures for improving performance are implemented in order to improve the efficiency of event processing in the subsequent OS.

Although an example of two buffers (first buffer 121b1 and second buffer 121b2) has been described above, the number of buffers is not limited to two. Changing the type of memory chunk, changing the size of the memory chunk, changing the data arrangement in the memory chunk, controlling the number of moves, and other measures to improve performance are all performed in a single move between two buffers. It is not necessary, and may be executed sequentially in multiple stages using three or more buffers.

Also, although an example of movement in event units has been described, movement is not limited to event units. When the OS processing system such as network transmission processes in units of accumulated bytes without being constrained by the boundaries of individual events, movement of events between buffers is not limited to units of events (0 or more events). . It may be only a part of a certain event, or a combination of consecutive event parts (for example, when event A, event B, and event C are accumulated in order, after the first half of event A is moved, event A (remaining second half of event A), all of event B, and a part of the first half of event C combined).

If there is no data to be transmitted in the first buffer _121b1 (S60; No), the process proceeds to step S62.

It is the application writing means 105 that adds the event to the first buffer _121b1 . After adding the event to the first buffer _121b1 (FIG. 10), the application writing means 105 calls the socket write requesting means 102a. The application writing means 105 is asynchronously called by the threads 103 operating in parallel and accumulates events in the first buffer _121b1 in a non-blocking manner. As the buffer, for example, a queue provided by Java (java.util.concurrent.ConcurrentLinkedQueue) is used, and a FIFO buffer that manages pointers to memory chunks is used. Efficient ring buffers can be implemented by reusing memory chunks managed by the buffer pool. The buffer pool memory chunk should be normalized to a memory size slightly larger than the typical event size. Large events that do not fit in memory chunks are stored in multiple chunks. The chunk size is adjusted to be 1/2 power of the page size. As with the first buffer 121b- ₁ , the second buffer 121b- ₂ can also use a FIFO queue (for example, java.util.concurrent.ConcurrentLinkedQueue) that holds pointers to memory chunks storing event information.

Next, when the second buffer _121b2 contains data to be transmitted (S62; Yes), the socket write request means 102a issues an OS asynchronous transmission request to the OS execution means 100 to request event processing ( S63). For example, Java's AsynchronousSocketChannel. Call write( ) gathering write to send multiple memory chunks to request processing of multiple events in one call. If there is no data to be transmitted in the second buffer _121b2 (S62; No), the socket write request means 102a requests the flag management means 107 to clear the flag (S64). After confirming that there is no data in _{the first} buffer 121b1 (S60), it is confirmed that there is no data in the _second buffer _121b2 (S62). 2 buffer 121b ₂ ) has been completely transmitted, the flag is cleared, and depending on the situation, the OS asynchronous transmission call that has been continuously made multiple times with the flag set is terminated. If an event is added to the first buffer 121b1 before the flag is cleared after it is determined that the transmission has ended, the OS process is executed together with the next event.

The callback processing means 102b shown in FIG. 12 receives a completion notification from the OS execution means 100 when the OS execution means 100 completes the processing of the write event of the socket write request means 102a, and writes to the corresponding socket. It executes asynchronously with the request means 102a. The callback processing means 102b receives the network transmission result executed by the OS executing means 100 (S50). If the transmission result is normal (S51; Yes), the callback processing means 102b deletes the transmission completion data from the second buffer _121b2 (S52), and calls the socket write request means 102a (S53). . If the transmission result is abnormal (S51; No), the callback processing means 102b performs exceptional processing (disconnection, etc.) such as disconnection of communication or timeout (S54).

(Operation of information processing device)
The operation of the second embodiment will be described separately for (1) basic operation and (2) data transmission operation.

FIG. 9 is a schematic diagram for explaining an example of data transmission/reception operations according to the second embodiment.

(1) Basic operation First, when the server device 1 receives data from the network 4, the socket reading means 101 receives data from the source 131 of the network 4 via the channel 130 and the socket corresponding to the channel (corresponding to the receiving terminal device). A port with a certain IP address) is read and written to the intermediate buffer 121B. Data is added to intermediate buffer 121B. Separate buffers are prepared for each channel or socket. A channel/socket is used for both transmission and reception, and one channel/socket is prepared for each corresponding terminal device (a specific program that becomes a communication partner of the terminal device). One application buffer is shown in the drawing, but in practice, it is managed separately for transmission and reception. In addition, the intermediate buffer 121B is managed as one buffer pool for all channels. , as a transmission intermediate buffer.

The subsequent write operation to the application buffer 120 is omitted because it is common to the first embodiment.

Next, the application execution means 103 reads the data of the application buffer 120 and processes it in the thread.

Also, when transmitting data processed by the thread of the application execution unit 103 to the network 4 , the application execution unit 103 writes the data processed by the thread into the application buffer 120 . In the second embodiment, the case where the application writing means 105 performs multithread parallel processing will be mainly described.

Depending on the destination terminal device for which the data in the application buffer 120 is intended, the application writing means 105 writes an intermediate buffer 121B, in particular the first buffer 121b ₁ , corresponding to the destination terminal device, more precisely to the channel or socket. per thread. In the first buffer _121b1 , data are sequentially written in areas prepared for each thread. In order to improve the efficiency of parallel processing by the application writing means 105, the application writing means 105 writes data (process result events) to the intermediate buffer 121B in a non-blocking manner.

Next, the socket writing means 102 sequentially moves data from the first buffer 121b- ₁ to the second buffer 121b- ₂ at arbitrary timing. Moving refers not only to literally moving a memory chunk holding data between buffers, from the first buffer 121b ₁ to the second buffer 121b ₂ , but also to copying the target data to the second buffer and then moving it to the second buffer. 1 includes the case of deleting from the buffer. In addition, movement is not limited to simple one-to-one movement, but can be used to change the buffer type, memory chunk size, arrangement method within a memory chunk, adjust the number of events to be moved, or change the number of events to be moved. It also includes conversion into a data retention form that is easy for execution means to process. In order to carry out these conversions step by step, the number of buffers (the number of stages of buffers) such as the third buffer and the fourth buffer may be increased. In addition, in order to reduce the load of memory allocation and release each time a buffer is used, memory chunks that hold data can be managed in a buffer pool that reuses pre-allocated memory. A buffer pool can also be shared by the first buffer and the second buffer. A single buffer pool can also be shared even when multiple channels manage their own buffers. A buffer pool often holds one or more types of standardized size memory chunks. Since the buffer pool uses the memory allocated from the system when the communication management program is started, allocation and freeing of memory using the buffer pool memory does not involve system calls, and the processing is light. , and does not cause system memory fragmentation. The buffer pool secures an appropriate amount at startup, but if there is a shortage during execution, or when the shortage is predicted, the OS will be overloaded, so if possible, It is preferable to make a request to the OS to secure additional memory and expand the buffer pool at an appropriate time. The types of memory chunks secured by the buffer pool and the size of the chunks are appropriately tuned according to the usage pattern. As the memory chunk handled by the first buffer, a single size (for example, 256 bytes) slightly larger than the average event size is selected from the non-direct buffer managed by the normal heap. As the memory chunk handled by the second buffer, a direct buffer of a size and type that is easy for the OS to handle, such as a page size or a half of the page size (eg, 2 KB) is selected. As for the size of the memory pool, the buffers obtained from the OS are used in small portions, so the page size or a value divided by a power of 2 of the page size should be used with the page size and memory boundaries in mind. , do not adopt arbitrary values such as 25 bytes or 50 bytes.

The next timing of moving from the first buffer to the second buffer may be every predetermined time interval, or the first buffer 121b- ₁ or the chunk stored in the first buffer 121b- ₁ . It may be when the amount of data reaches a predetermined amount, or when the number of chunk-accumulated events in the first buffer 121b- ₁ or in the first buffer 121b- ₁ reaches a predetermined number. There may be.

A trigger for activating the socket writing means 102 or a trigger for moving data from the first buffer _121b1 to the second buffer _121b2 may be polling or a timer, or all or part of it. It may be immediately after execution of the application writing means 105 .

When three or more stages of buffers are used, the timing, trigger, movement method, etc. for moving data between stages are described for the above-described first and second buffers. The method can be employed independently at each stage. In the above example, when moving, multiple operations (chunk memory type change, chunk size change, movement amount limit, etc.) were performed at the same time, but the operations were divided and the intermediate results were stored as additional buffers. can be considered. In that case, the movement timing and trigger may be the same for all stages.

Next, the socket writing means 102 reads the data in the second buffer _121b2 and writes it to the channel 130 by means of the socket. Data is transmitted to source 131 via channel 130 . At this time, the data is taken out from the second buffer _121b2 , and the OS executing means 100 performs transmission processing as a transmission target. _121b2 . Data for which transmission has not been completed will continue to remain in the second buffer _121b2 . _Here , all the data accumulated in the second buffer _121b2 is transmitted at once. Control may be performed to read and transmit only a portion of the data, instead of reading all at once, for example, in consideration of restrictions. Alternatively, _{the number of events and the number of bytes transferred from the first buffer 121b-1 to} the second buffer 121b- ₂ are limited in advance so that the data accumulated in the second buffer 121b-2 does not become huge. good too.

A case in which data processed by the thread of the application execution means 103 is transmitted from the OS execution means 100 to the network 4 will be described in detail below.

(2) Data Transmission Operation FIG. 10 is a schematic diagram for explaining an example of data transmission operation. Thread 1 and thread 2 asynchronously generate events A, C, F and events B, D, E, respectively, and call application writing means 105 and socket write request means 102a, and generate events A to F, respectively. to the network 4. Application writing means 105 adds one event generated by thread 1 and thread ₂ to first buffer 121b1 and calls socket writing means 102a. If the OS kernel 100 is already executing event processing, the socket writing means _102a ends without processing. It moves zero or more events to the second buffer _121b2 , and requests the OS kernel 100 to process the events held in the second buffer _121b2 . The state of whether the OS kernel 100 is processing an event is managed by a CAS flag provided by the flag management means 107 . When the OS kernel 100 completes the processing of the requested event, the callback thread (the callback thread of thread 1) executes the callback processing means 102b asynchronously with both thread 1 and thread 2. FIG. The callback thread confirms the progress of event processing and adjusts the second buffer _121b2 (deleting the processed event from the second buffer or transferring the event from the first buffer to the second buffer). ) to recursively and exclusively call the socket writing means a, and process the events accumulated in the first buffer _121b1 during processing by the OS kernel 100 as well. The callback thread repeats the processes of the socket write request means 102a and the callback processing means 102b until there are no more events held by the intermediate buffer 121B (that is, the first buffer 121b ₁ and the second buffer 121b ₂ ). operate.

The application execution means 103, for example, processes data by a plurality of threads 1 and 2, and transmits event A and event B as processing results to the same terminal device (more precisely, the same socket or channel). Then, the event A and event B are written by the application writing means 105 to the first buffer _121b1 corresponding to the socket for communication to the destination terminal. It is assumed that processing of threads 1 and 2 occurs asynchronously. The first buffer 121b ₁ is, for example, a thread-safe, non-blocking ring buffer (for example, it can be realized by registering a pointer to a memory chunk storing an event in a non-blocking, thread-safe FIFO queue java.util.ConcurrentLinkedQueue). . The application writing unit 105 writes events A and B in non-blocking areas (chunks) that are different for each thread (1) and (2). In particular, if standardized size memory chunks are used instead of event size memory chunks, the memory chunks can be, for example, java. nio. The ByteBuffer is also used to manage the start and end positions of the stored events. Also, when storing events in memory chunks of a normalized size, for events larger than the chunk size, events may be stored in chunk groups spanning multiple chunks, and a pointer to the chunk group may be added to the ring buffer. .

First, for event A of thread 1, application writing means 105 calls socket writing request means 102a to request processing of event A of first buffer _121b1 (3). Since the caller is the application writing unit 105, the socket write request unit 102a refers to the CAS flag of the flag management unit 107. Since the flag is not set, the socket write request unit 102a sets the flag (4), and writes the first buffer _121b1. , and since there is an event, event A in the first buffer 121b- ₁ is moved to the second buffer 121b- ₂ (5). Here, the second buffer 121b ₂ , like the first buffer 121b ₁ , also stores pointers to memory chunks that store events in, for example, a non-blocking ring buffer (for example, a non-blocking thread-safe FIFO queue java.util.ConcurrentLinkedQueue). can be realized by registering). However, since the number of threads that operate the second buffer is limited to one at most by the flag management means 107, it does not have to be thread-safe. After moving event A to the second buffer _121b2 , the socket write request means 102a calls the thread 1 to proceed with the next process, and leaves the process to the OS kernel 100 (6). The processing ends without waiting for the processing of the kernel 100 to be completed, and the processing of the thread 1 is returned to (7).

On the other hand, for event B of thread 2, application writer 105 calls socket write requester 102a to request processing of event B of first buffer _121b1 (8). Since the caller is the application writing means 105, the socket write request means 102a refers to the CAS flag of the flag management means 107 (9). (4) so it is no longer flagged. The socket write request means 102a does not wait until processing becomes possible, ends processing in a non-blocking manner, and returns to the processing of thread 2 (10).

For thread 1, the application executing means 103 continues to process data, and the application writing means 105 writes event C as a processing result into the first buffer _121b1 (11). The first buffer _121b1 holds unprocessed events B and C (11). For event C of thread 1, application writing means 105 requests processing of the data in first buffer 121b1 (not only added data C but also already added data B). 102a (50). Since the caller is the application writing means 105, the socket write request means 102a refers to the CAS flag of the flag management means 107. In this case, the flag is already set due to the previous processing of the data A (4). so it can no longer be flagged. The socket write requesting means 102a does not wait until the process becomes ready, but ends the processing of the socket write requesting means 102a in a non-blocking manner and returns to the thread 1 process.

Regarding the network transmission of the event A of the thread 1, specifically, when the socket write request means 102a leaves the processing to the OS kernel 100 (6), an OS system call (for example, AsynchronousSocketChannel.write() of JAVA ) to request transmission of event A(12) existing in the second buffer _121b2 . The socket write request means 102a requests the OS execution means 100 (OS kernel) to write event A in the second buffer _121b2 , ends the process, and returns to the process of thread 1 (7).

As for network transmission of event A of thread 1, the OS kernel 100 that has received the transmission request divides event A into appropriate sizes and transmits events A1 and A2 (13), as in the first embodiment. . The size of division, the number of divisions, and the transmission interval depend on the OS, network load, and the like.

On the other hand, regarding event B of thread 2, while OS kernel 100 is processing event A, application writing means 105 continues to process event B of first buffer _121b1 . 102a is called (8), but the socket write request means 102a is still processing event A (4) and the CAS flag of the flag management means 107 is set (9). Without moving the event B in the _second buffer 121b-1 to the second buffer 121b- ₂ , the application writing means 105 terminates the processing, and the thread 2 proceeds to the next processing (10). At this time, the events B and C are accumulated in the first buffer _121b1 , and the event D has not yet been generated (11). The application executing means 103 processes data by the thread 2 and generates an event D at a later timing.

Next, when the OS kernel 100 is requested to send the event A by the thread 1, when the transmission of the event A is completed, the callback processing means 102b is started as the callback thread of the thread 1 (14), and the callback processing means 102b confirms the number of bytes that have been transmitted, and in this case the entire event A has been transmitted, so it deletes event A from the first buffer _121b1 (15). At this point, events B and C are present in the first buffer _121b1 (11). After that, the callback processing means 102b calls the socket write request means 102a (16).

Subsequently, in the callback thread, the socket write request means 102a checks whether events are accumulated in the first buffer 121b _{-1 .} Move to buffer _121b2 (17). In this case, since the capacity of the second buffer 121b2 is sufficient, all the events in the first buffer 121b1 are moved. You may move only a part of the event (for example, only event B). By chance, at a later timing, the application writing means 105 writes the processing result event D of the thread 2 into the first buffer _121b1 (18). At this point, the first buffer 121b1 holds only event D.

As for event C of thread 1, the socket write request means _102a is subsequently called. , event C is not moved to the second buffer _121b2 , the application writing means 105 terminates the processing, returns to the thread 1, and advances the processing (19). The application executing means 103 processes data by the thread 1 and generates an event F at a later timing (20). Also, as described above, the callback thread processes the event B and the event C of the first buffer 121b1 at a later timing.

Next, in the callback thread, since the call source is the callback processing means 102b, the socket write request means 102a continues to call the OS system call, and transmits event B and event C of the second buffer _121b2 . Request (21). The socket write request means 102a requests the OS execution means 100 (OS kernel) to write event B in the second buffer _121b2 , and terminates the callback thread.

Next, the OS kernel 100, which has been requested to transmit events B and C by the callback thread, divides the events B and C into appropriate sizes and transmits them to the network. First, event B is divided into three and transmitted as events B1, B2, and B3, and the processing ends (the OS kernel completes the processing). The reason why only the event B is sent and not the event C, or the reason why the entire event B is sent instead of a part of the event B depends on the circumstances of the OS and the load on the server device 1 or the network 4 (22 ).

Also, regarding event D of thread 2, during event processing of the OS kernel 100 requested by the callback thread of thread 1, the application writing means 105 continues to process event D of the first buffer _121b1 . The socket write request means 102a is called (23), but since the socket write request means 102a is processing events B and C (16) and the CAS flag of the flag management means 107 is set (24), a socket write request is issued. The means 102a does not move the event D in the first buffer 121b- ₁ to the second buffer 121b- ₂ , the application writing means 105 terminates and returns to thread 2 to proceed with the next process (25). The application execution means 103 continues to process data by thread 2 and generates event E at a later timing (26). At this time, the event D is accumulated (18) in the first buffer _121b1 , and the event E has not yet been generated.

Next, the OS kernel 100, which is requested to send events B and C from the callback thread, completes the transmission of event B and activates the callback processing means 102b (27), and the callback processing means 102b transmits Check the number of bytes completed, and delete event B from the first buffer _121b1 , since in this case the entire event B has been transmitted.

At this point, thread 2 generates event E and writes event E to first buffer _121b1 by means of application writing means 105 . Events D and E are present in the first buffer _121b1 (28). In thread 2, application writing means 105 that has generated event E (26) calls socket writing request means 102a (30). The socket write request means 102a is still processing events C and D (27), and the CAS flag of the flag management means 107 is set ( ₃₁ ). Without moving events D and E to the second buffer _121b2 , the application writing means 105 terminates the processing and returns to thread 2, which advances the next processing (32).

When the OS kernel 100 is requested to send events B and C by the callback thread of the thread 1, after completing the transmission of the event B, it again activates the callback thread of the thread 1, and the activated callback processing means 102b , again calls the socket read request means 102a (29). The _socket write request means 102a checks whether the event is accumulated in the first buffer 121b _{-1 .} Move the event (33). At this point, the second buffer 121b2 holds events C, D and E.

Next, in the callback thread of thread 1, the socket write request means 102a calls the OS system call because the caller is the callback processing means 102b, and the events C, D, and E of the _second buffer 121b2. A transmission request is sent to the OS and the callback thread is terminated (34).

The OS kernel 100 then attempts to send events C, D, and E. First, the event C is divided into appropriate sizes (C1, C2, C3), the events C1 and C2 are transmitted, and the processing ends (the OS kernel completes the processing) (35). The reason for transmitting (35) only a part of event C (C1, C2) and not transmitting the remaining event C (C3), event D, and event E is the convenience of the OS as described above. At this point, the event F is accumulated in the first buffer _121b1 .

Next, when the OS kernel 100 completes transmission of part of event C, it activates (36) the callback processing means 102b again as the callback thread of thread 1, and the callback processing means 102b completes the transmission. In this case, since transmission of C1 and C2 of event C has been completed, portions corresponding to C1 and C2 of event C are deleted from the second buffer _121b2 . If C is stored in a single chunk, the entire chunk cannot be freed until the transmission of C3 is complete. For example, java. nio. When the transmission start position and the transmission end position are managed using ByteBuffer, the entire C is released after the processing of C3 is completed, and the transmission start position is moved from C1 to C3 to complete C1 and C2. Then, the socket write request means 102a is called again (37).

Next, in the callback thread, the socket write request means 102a checks whether the event is accumulated in the first buffer _121b1 because the caller is the callback processing means 102b. Therefore, event F is moved to the second buffer 121b2. Event F moves from the first buffer 121b1 to the second buffer 121b2, the first buffer being empty (38) and the second buffer holding events C3, D, E, F (39). The socket write request means 102a subsequently makes an OS system call and requests the OS execution means 100 (OS kernel) to write events C3, D, E, and F (39) of the _second buffer 121b2. Terminate the callback thread (40).

Next, the OS kernel 100 requested to transmit events C3, D, E, and F divides events C and D into appropriate sizes and transmits events C3, D1, and D2 (41). The reason why only the events C3 and D are transmitted and not the events E and F is the convenience of the OS as described above.

Next, the OS kernel 100, to which transmission of events C3, D, E, and F has been requested, activates callback processing means 102b as a callback thread (42) after completing the transmission of events C and D, and calls the callback processing means 102b. The back processing means _102b confirms the number of bytes that have been transmitted. ) and event D. Then, the socket write request means 102a is called again (43).

Next, in the callback thread, the socket write request means 102a first confirms whether an event is accumulated in the first buffer _121b1 because the caller is the callback processing means 102b. An OS system call is made without moving the event to _{the second} buffer _121b2 , and a write request is made to the OS execution means 100 (OS kernel) to write events E and F (44) of the second buffer 121b2. Terminate the back thread (45).

Next, the OS kernel 100, which has been requested to transmit events E and F, divides events E and F into appropriate sizes and transmits events E1, E2 and F (46).

Next, the OS kernel 100 to which the transmission of the events E and F has been requested activates the callback processing means 102b as a callback thread when the transmission of the events E and F is completed (47). confirms the number of bytes that have been transmitted. In this case, since transmission of all events E and F has been completed, events E and F are deleted from the second buffer _121b2 . Then, the socket write request means 102a is called again (48).

After that, in the callback thread, the socket write request means 102a checks the first buffer 121b- ₁ and the second buffer 121b- ₂ in order because the caller is the callback processing means _102b . and the second buffer _121b2 , the CAS flag of the flag management means 107 is cleared (49) and the callback thread is terminated.

(Effect of Second Embodiment)
According to the above-described second embodiment, the intermediate buffer 121B is provided between the application writing means 105 and the socket writing means 102, and the first buffer _121b1 of the intermediate buffer 121B is used for the writing of the application writing means 105. Write data is accumulated for each thread in a non-blocking manner, the write operation of the socket write request means 102a is executed according to the CAS flag, the CAS flag is managed by the flag management means 107, and the write operation of the socket write request means 102a is executed. A flag is set at the start of loading, and the callback processing means _102b that receives notification of the event processing completion of the OS execution means 100 releases the flag. ₂ , the events are converted into a format suitable for the processing of the OS execution means, such as 2, and then the events in the second buffer 121b ₂ are processed by the OS execution means 100. The write operation does not directly affect the transmission event processing operation of the OS execution means 100 (there is no waiting time for the application writing means 105 and the OS execution means 100 to respond to each, and each event The number of calls to the OS execution means 100 is reduced compared to calling the OS execution means 100), application processing and data transmission can be executed in a non-blocking manner to speed up communication. In particular, transmission processing to the network, which takes a relatively long time, is performed with a short wait time (latency), continuous processing as much as possible, and non-blocking, giving priority to network transmission processing, increasing transmission throughput, and asynchronous transmission. Application processing can be executed in parallel in a non-blocking manner during the waiting time for (NIO) processing.

(Modification)
In the above-described second embodiment, the socket write request means 102a 1 for requesting event processing to the OS execution means 100 only in response to a call from the application write means 105 and the socket write request means 102a ₁ for calling It may be divided into a socket flash writing means _102a2 that requests event processing to the OS execution means 100 only in response to a call from the back processing means 102b. In this case, step S40 of FIG. 11 becomes unnecessary, step S53 of FIG. 12 changes to "request event processing to OS execution means 100", and the operation of FIG. 13 is carried out by socket flash writing means _102a2 . . Even in the case of mounting in this way, the same effects as those of the second embodiment can be obtained.

[Other embodiments]
The present invention is not limited to the above embodiments, and various modifications and combinations are possible without departing from the scope of the present invention.
(A) Non-blocking exclusive control by CAS The basis of the present invention is non-blocking OS execution means 100 calling by CAS. In network transmission processing, calling the OS execution means 100 may involve transmitting only a part of the data requested to be transmitted, setting up the transmission buffer, transmission processing, adjustment of the transmission buffer after completion of transmission, etc. cannot be sent concurrently. Therefore, some kind of exclusive control is required. Therefore, using the functions of the OS, implement it with a Synchronized method etc., so that only a single thread can be executed at the same time, and the other threads wait for the end of the running thread and resume execution one by one for a while. It is common to perform exclusive control. However, in applications such as a game server that relays changes in game objects in a network game in large quantities and frequently, small data will be sent and received in large quantities frequently, and exclusive control using OS functions will also occur frequently. Therefore, the overhead of calling the OS function cannot be ignored, and the processing performance of the server function is lowered. Therefore, the present invention performs exclusive control using non-blocking CAS executed by atomic instructions. During OS function processing of an event, even if an OS function call is attempted for another event, it will not be executed and will end without waiting due to exclusive control of CAS. Since it is not possible to process each event sequentially, the events are temporarily accumulated in a buffer, and the thread executing the OS function processing not only the events assumed at startup, but also the events accumulated before startup, Alternatively, it is devised to process events accumulated during execution of OS function processing. In general, OS function calls take longer than normal memory processing, so in applications such as game servers, there is a high possibility that new events will be accumulated during OS function calls. Although two typical non-blocking exclusion control methods by CAS have been shown in the first and second embodiments, the present invention is not limited to these two embodiments.
(B) Format of Virtual Ring Buffer for Accumulating Events If an OS function call takes a long time, the OS is divided into function calls and callbacks so that another process can be executed asynchronously while the function call is being executed. Provide a mechanism for processing. Therefore, the callback after event processing occurs asynchronously with the function call for event processing. Application event generation is also asynchronous. In order to arbitrate these, events must be accumulated in a ring buffer so that accumulation and processing can be performed completely asynchronously so that events can be processed in FIFO. There are various variations of ring buffers, the first embodiment shows a ring buffer that stores event data in byte sequences, and the second embodiment shows a ring buffer that stores pointers to memory chunks that store event data. Although shown, it is not intended to be limited to only the two disclosed methods and variations thereof.
(C) Asynchronous Processing of Event Accumulation and OS Function Calling Accumulation of events can be synchronized with the occurrence of events. On the other hand, the accumulated event processing can be started from the event processing completion callback. However, if event processing is not working at all, for example, another mechanism is required to activate the first event processing. In the first embodiment and the second embodiment, a method is disclosed in which event accumulation is used as a trigger only when event processing is stopped. However, as mentioned above, this trigger may be completely asynchronous, such as with a timer, or it may be synchronous with event accumulation once every or several times. The trigger may be a function call (method or function call), signaling using an OS function, or other methods. In the second embodiment, in consideration of the efficiency of event processing of the application, a method of giving priority to method calls from callbacks as triggers has been shown. An appropriate method is selected according to the application to be applied, and the method is not limited only to the methods disclosed as the examples and their modifications.
(D) Reuse of memory When memory allocation and deallocation are repeated frequently, calling the OS function each time becomes an overhead. Buffer pools that reuse allocated memory instead of reusing it are common. To avoid memory fragmentation and associated garbage collection, and to promote memory reuse, the buffer pool should be managed as a set of standardized memory chunks, and depending on the memory size used by the application, the required number of It is also common to combine chunks. To implement a virtual ring buffer, it is better to use a memory buffer pool. The size and number of chunks, and the type of memory to be used (direct buffer or non-direct buffer) are appropriately selected according to the application to be applied, and selection by the method disclosed as the embodiment and its modification is not limited to

FIG. 5 is a schematic diagram showing a modification of the layer configuration.

For example, the present application provides an example in which a buffer (a) is provided between the application layer (application 112) and the presentation layer and session layer (communication management program 111) among the seven layers of the OSI (Open Systems Interconnection) reference model. As described above, the buffers (b) to (e) may be provided at different positions in different layer configurations (a) to (e).

Here, in order to increase the transmission throughput, it is necessary to wait in the layer related to transmission in the lower layer, and in order to prevent latency in the lower layer, requests and calls to the lower layer must be lock-free (non-blocking) for the upper application. is desirable. Since some kind of aggregation occurs from the top to the bottom, in a multitasking environment, some kind of exclusive control is usually required so that the data of each thread is not mixed. A lock-free algorithm is desirable because the use of the OS "lock (mutex)" for exclusive control increases the processing load. In particular, in the case of a game server that transmits a large amount of packets for synchronization at different frequencies, such as streaming, it is not desirable to lock each packet transmission. Since the exclusive control of the OS cannot be used in Woo, it is necessary to independently perform exclusive control by the application.

In the case of a (first embodiment and second embodiment), data is sequentially transmitted to a TCP or UDP (User Datagram Protocol) channel created by a Java VM (virtual OS). Exclusive control is required when multiple threads use the same channel. In the case of RUDP (Reliable User Datagram Protocol), an application that uses UDP sockets must independently create a reliability assurance layer such as ACK (acknowledgement) and retransmission.

In the case of B, the difference from A is whether it is a virtual OS or a Native OS.

In the case of c, stateless (connectionless) UDP is feasible. It is usually not possible to directly call the layers inside the OS, so the feasibility is low, but it is possible if there is a configuration for direct calling. Multiple applications and threads need to aggregate all communications to multiple destinations (terminal devices) sharing the NIC.

In the case of D, the speed can be increased by bypassing the protocol stack of the OS. You need to create your own protocol stack. (For example, DPDK (Data Plane Development Kit) or the like can be used. https://www.dpdk.org/). NIC drivers are not NDIS, they are specialized and are usually dependent on a particular NIC product. In the case of UDP, it may be possible to send directly as a datagram without going through a socket. It is usually not possible to directly call the internal layer of the OS, so the feasibility is low, but it is possible if there is a dedicated NIC driver like DPDK. C. Similarly, multiple applications and threads need to aggregate all communications to multiple destinations (terminal devices) that share the NIC.

In the case of E, since the application is completely hardware-dependent, it is used for non-special purposes such as embedded systems. C. Similarly, multiple applications and threads need to aggregate all communications to multiple destinations (terminal devices) that share the NIC.

Next, each buffer (a) to (e) will be explained.

In the case of (a), as a general usage, it is limited to JAVA and independent of the OS, and is aggregated so as not to mix multithreaded application packets (application transmission units) in units of sockets.

In the case of (b), the general usage is language-dependent and OS-dependent, and is the same as (a). (a) In the case of via, the parameters may be passed through as they are, and in the case of distributed writing, if the transmission byte buffers are in a continuous area, they may be optimized by combining them into one transmission buffer. Here, distributed writing means, for example, Java's AsynchronousSocketChannel. A function of write( ) that specifies multiple buffers in which one or more variable-length data blocks are grouped and requests transmission.

In the case of (c), the work is usually done inside the OS and in the OS kernel, and the application handles it cross-sectionally and aggregates it for each protocol. Note that it is necessary to add a protocol header. When data is written to a TCP socket, the data stream state for each connection and the boundary of the transmission unit of application packets are irrelevant. It is divided into appropriate sizes and passed to the protocol driver. At that time, there is a possibility that data copying or repacking may occur. Since UDP sockets are connectionless, data written to a socket is transmitted without buffering and is not sent all at once. When sending a plurality of data collectively by RUDP, they are collectively written before being written to the UDP socket.

In the case of (d), the task is usually done by the protocol driver inside the OS, and the application handles it cross-sectionally and aggregates various protocols for each NIC. Note that it is necessary to add a protocol header. Aggregate all data for each NIC, combining and splitting each packet and adding protocol headers.

In the case of (e), it becomes work inside the NIC. Processing such as division, combination, and compression according to the network type, addition of a header, etc., conversion to an electrical signal corresponding to the bit string, and transmission to the communication line.

Although the functions of the means 100 to 107 of the control unit 10 are implemented by programs in the above embodiment, all or part of the means may be implemented by hardware such as ASIC. Also, the program used in the above embodiment can be stored in a recording medium such as a CD-ROM and provided. In addition, replacement, deletion, addition, etc., of the steps described in the above embodiment are possible without changing the gist of the present invention. Also, the function of each means may be appropriately combined with other means, or may be separated into a plurality of means.

In the above embodiments, processing of network transmission events has been mainly described, but the present invention does not limit the events to be processed to network transmission events only. All or a part of each means of the present invention can be applied to event processing other than network transmission, especially processing that requires a relatively long time to request processing operations from the OS function (processing request for OS function to enable asynchronous processing). Processing that provides means and callback means, typically various I/O operations), more specifically, output operations to various media such as networks and disks, replaces the corresponding request means and callback means Therefore, it can be applied. Further, in order to process an event by sequentially calling OS functions a plurality of times, it is possible to combine a plurality of event processing schemes of the present invention.

Reference Signs List 1: server devices 2a, 2b, 2c: terminal device 4: network 10: control unit 11: storage unit 12: memory 13: communication unit 100: OS execution means (OS kernel)
101: socket reading means 102: socket writing means 102a: socket writing request means 102b: callback processing means 103: application executing means 104: application reading means 105: application writing means 106: buffering means 107: flag management means 111: communication management program 112: application 120: application buffer 121: ring buffer 121B: intermediate buffer 121b1: first buffer _121b2 : _second buffer 130: channel 131: source

[1] a computer,
event accumulation means for accumulating events to be processed;
buffering means for accumulating the events;
a processing means for processing the accumulated events;
act as a flag manager that accepts calls and sets flags exclusively,
The processing means includes processing request means for requesting event processing, and callback processing means for receiving a completion notification and executing when the event processing is completed,
The flag management means sets the flag exclusively before the process request means starts processing the event, and cancels the flag after the process of the callback processing means ends;
The processing request means receives a call at a timing after the event accumulation means finishes accumulating the event in the buffering means and at a timing after the event processing ends for the callback processing means, and responds to the flag of the flag management means. an information processing program for terminating without processing if the flag is not set, and processing the event accumulated by the buffering means if the flag is set.
[2] The buffering means has a first buffering means for accumulating events and a second buffering means for accumulating the events accumulated in the first buffering means,
The processing request means moves and accumulates the event from the first buffering means to the second buffering means when the flag is set, and the second buffering means accumulates the event. The information processing program according to [1], which processes all or part of the event.
[3] One or more buffering means are further provided between the first buffering means and the second buffering means, before the first buffering means, or after the second buffering means. The information processing program according to [2] above.
[4] The information processing program according to [2] or [3], wherein at least one of data block size, number, type, and event holding format is changed in the movement between the buffering means.
[5] The information processing program according to any one of [2] to [4], wherein the number and size of movement events are restricted according to predetermined conditions in movement between the buffering means.
[6] The information processing according to any one of [1] to [5], wherein the event accumulation operation of the event accumulation means and the processing operation of the processing means are executed asynchronously in the buffering means. program.
[7] The information according to any one of [1] to [6], wherein the buffering means asynchronously accumulates events by respective event accumulation means executed by a plurality of event generators operating in parallel. processing program.
[8] The information processing program according to any one of [1] to [7], wherein the buffering means is a ring buffer.
[9] The information processing program according to [1], wherein the buffering means is a ring buffer that sequentially accumulates the event itself in a memory area.
[10] The buffering means has a two-stage ring buffer structure, the first stage ring buffer stores events of the event storage means operating in parallel, and the second stage ring buffer responds to the processing of the processing means. The information processing program according to the above [2], [6], or [7], which connects and divides the event into a size determined by the above and holds the number of events determined according to the processing means.
[11] The information processing program according to any one of [1], [2], or [6] to [10], wherein the buffering means stores the event in a direct buffer.
[12] The information processing program according to any one of [1], [2], or [6] to [10], wherein the buffering means accumulates the event in a buffer of a buffer pool.
[13] The information according to [10], wherein the buffering means accumulates events in buffers of buffer pools holding different buffer sizes for the first stage ring buffer and the second stage ring buffer. processing program.
[14] The information processing program according to any one of [1] to [13], wherein the processing means finishes event processing after processing all the accumulated events.
[15] event accumulation means for accumulating events to be processed;
buffering means for accumulating the events;
a processing means for processing the accumulated events;
a flag management means for accepting calls and setting flags exclusively,
The processing means includes processing request means for requesting event processing, and callback processing means for receiving a completion notification and executing when the event processing is completed,
The flag management means sets the flag exclusively before the process request means starts processing the event, and cancels the flag after the process of the callback processing means ends;
The processing request means receives a call at a timing after the event accumulation means finishes accumulating the event in the buffering means and at a timing after the event processing ends for the callback processing means, and responds to the flag of the flag management means. If the flag is not set, the information processing device ends without processing, and if the flag is set, the event accumulated by the buffering means is processed.
[16] An information processing method executed on a computer, comprising :
an event accumulation step for accumulating events to be processed;
a buffering step of accumulating the events;
a processing step of processing the accumulated events;
a flag management step for accepting and exclusively flagging calls;
The processing step includes a processing request step that requests processing of the event, and a callback processing step that is executed upon receiving a completion notification when processing of the event is completed,
The flag management step exclusively sets the flag at a timing before the start of event processing in the processing request step, and cancels the flag at a timing after the processing in the callback processing step ends,
The process request step accepts a call at the timing after the event accumulation in the event accumulation step ends and the event processing in the callback processing step ends, and if the flag is not set, the process is not performed. an information processing method for processing the accumulated event if set.

Claims (16)

the computer,
event accumulation means for accumulating events to be processed;
buffering means for accumulating the events;
a processing means for processing the accumulated events;
act as a flag manager that accepts calls and sets flags exclusively,
The processing means includes processing request means for requesting event processing, and callback processing means for receiving a completion notification and executing when the event processing is completed,
The flag management means exclusively sets the flag at a timing before the event processing requesting means starts processing the event, and cancels the flag at the timing after the processing of the callback processing means ends,
The processing request means receives a call at a timing after the event accumulation means finishes accumulating the event in the buffering means and at a timing after the event processing ends for the callback processing means, and responds to the flag of the flag management means. an information processing program for terminating without processing if the flag is not set, and processing the event accumulated by the buffering means if the flag is set. The buffering means has a first buffering means for accumulating events and a second buffering means for accumulating the events accumulated in the first buffering means,
The processing request means moves and accumulates the event from the first buffering means to the second buffering means when the flag is set, and the second buffering means accumulates the event. 2. The information processing program according to claim 1, which processes all or part of said events that are present. 1. The method further comprises one or more buffering means between said first buffering means and said second buffering means, before said first buffering means or after said second buffering means. 3. The information processing program according to 2. 4. The information processing program according to claim 2, wherein at least one of data block size, number, type, and event holding format is changed in the movement between the buffering means. 5. The information processing program according to any one of claims 2 to 4, wherein in the movement between said buffering means, the number and size of movement events are restricted according to predetermined conditions. 6. The information processing program according to any one of claims 1 to 5, wherein the buffering means executes an event accumulation operation of the event accumulation means and a processing operation of the processing means asynchronously. 7. The information processing program according to any one of claims 1 to 6, wherein in the buffering means, event accumulation means executed by a plurality of event generators operating in parallel accumulate events asynchronously. 8. The information processing program according to claim 1, wherein said buffering means is a ring buffer. 2. The information processing program according to claim 1, wherein said buffering means is a ring buffer that sequentially accumulates said events themselves in a memory area. The buffering means has a two-stage ring buffer structure, the first stage ring buffer stores events of the event storage means operating in parallel, and the second stage ring buffer is determined according to the processing of the processing means. 8. The information processing program according to claim 2, 6 or 7, wherein the events are linked and divided into the same size and held in a number determined according to the processing means. 11. The information processing program according to claim 1, wherein said buffering means stores said event in a direct buffer. 11. The information processing program according to claim 1, wherein said buffering means accumulates said event in a buffer of a buffer pool. 11. The information processing program according to claim 10, wherein said buffering means accumulates events in buffers of buffer pools holding different buffer sizes in said first stage ring buffer and said second stage ring buffer. 14. The information processing program according to any one of claims 1 to 13, wherein the processing means finishes event processing after processing all the accumulated events. event accumulation means for accumulating events to be processed;
buffering means for accumulating the events;
a processing means for processing the accumulated events;
a flag management means for accepting calls and setting flags exclusively,
The processing means includes processing request means for requesting event processing, and callback processing means for receiving a completion notification and executing when the event processing is completed,
The flag management means exclusively sets the flag at a timing before the event processing requesting means starts processing the event, and cancels the flag at the timing after the processing of the callback processing means ends,
The processing request means receives a call at a timing after the event accumulation means finishes accumulating the event in the buffering means and at a timing after the event processing ends for the callback processing means, and responds to the flag of the flag management means. If the flag is not set, the information processing device ends without processing, and if the flag is set, the event accumulated by the buffering means is processed. the computer,
an event accumulation step for accumulating events to be processed;
a buffering step of accumulating the events;
a processing step of processing the accumulated events;
a flag management step for accepting and exclusively flagging calls;
The processing step includes a processing request step that requests processing of the event, and a callback processing step that is executed upon receiving a completion notification when processing of the event is completed,
The flag management step exclusively sets the flag at a timing before the start of event processing in the event processing request step, and releases the flag at a timing after the processing in the callback processing step ends,
The process request step accepts a call at the timing after the event accumulation in the event accumulation step ends and the event processing in the callback processing step ends, and if the flag is not set, the process is not performed. an information processing method for processing the accumulated event if set.

Images