KR102194513B1 - Web service system and method using gpgpu based task queue - Google Patents

Abstract

According to one embodiment of the present invention, a system for providing a web service utilizing a task queue based on GPGPU comprises: a task queue created in GPU and processing a user request for a web service by using the multi-thread processing capability of GPGPU; and an HTTP server creating a plurality of producer threads and a plurality of consumers threads in response to an HTTP request if there is the HTTP request responding to the user request from the client, receiving a packet related to the HTTP request through the plurality of producer threads to the task queue, and checking whether an error has occurred with respect to data preprocessed by the task queue through the plurality of consumer threads and transferring the data to a web application server if there is no error as a result of the check. Therefore, the system can improve the performance by reducing work of the CPU.

Description

Web service providing system and method using GPGPP based task queue {WEB SERVICE SYSTEM AND METHOD USING GPGPU BASED TASK QUEUE}

Embodiments of the present invention relate to a system and method for providing a web service using a task queue based on General-Purpose Computing on Graphics Processing (GPGPU).

Web servers on the Internet are always ready and very open to handle a large number of unspecified user requests. However, when a large number of user requests occur, there are cases in which a failure occurs or a smooth web service is not possible.

Even a web server, which normally has no problem in handling user requests, cannot handle a large number of user requests that occur suddenly and the web server is down. If the web server is down, it can be restored by rebooting the system or by investing a considerable amount of time to restart the web server.

In order to prepare for this problem, we are trying to solve the problem by using a cloud service, a system that can increase the resources of the web server and allocate resources dynamically. Most of these efforts are costly and in some cases do not provide a complete solution.

Meanwhile, GPGPU is widely used in the field of HPC, games, simulation, and artificial intelligence, and the number is increasing. Many tasks are performed using the GPU, and the fields of use of the GPU are also developing in various ways.

The latest GPUs not only provide graphics processing but also provide high-performance floating-point arithmetic functions that support GPGPU programs. In addition, its performance continues to evolve so that it can create and process a large number of threads. If the GPU continues to evolve so that the performance of this GPU can be used in general applications, and the GPU assists the CPU to develop, the execution performance of general-purpose applications improves, and the hardware for executing high-performance general-purpose applications can further reduce costs. I can.

As related prior art, there is Korean Patent Application Publication No. 10-2017-0116439 (title of the invention: task scheduling method and apparatus, publication date: October 19, 2017).

An embodiment of the present invention utilizes a GPGPU-based task queue that can improve performance by reducing CPU work by designing a task queue capable of handling a large amount of requirements using GPGPU and processing part of HTTP on the GPU. Provides a web service providing system and method.

The problem to be solved by the present invention is not limited to the problem(s) mentioned above, and another problem(s) not mentioned will be clearly understood by those skilled in the art from the following description.

A web service providing system using a GPGPU-based task queue according to an embodiment of the present invention includes: a task queue that is created in a GPU and processes user requests of a web service by using the multi-thread processing capability of the GPGPU; And generating a plurality of producer threads and a plurality of consumer threads in response to an HTTP request corresponding to the user request from a client, and making the HTTP request through the plurality of producer threads. HTTP that receives a packet related to and transmits it to the task queue, checks whether an error has occurred with respect to the data preprocessed by the task queue through the plurality of consumer threads, and delivers the data to the web application server if there is no error. Includes the server.

The task queue may be processed so that a large amount of user requests does not exceed the capacity of the task queue using a circular queue algorithm.

The task queue may be implemented using a Compute Unified Device Architecture (CUDA) based on GPGPU technology, and may be implemented so that the CUDA thread operates like a circular queue to enable application processing.

The CUDA calls an HTTP packet error processing function using a kernel function to create the GPU with a plurality of threads, and the HTTP packet error processing function is a structure of task queue data defined in the kernel function and the size of the structure. By receiving as a parameter, the suitability of the packet for the HTTP request is checked, and a value is added to the error flag for return processing.

The consumer thread reads the data in the task queue asynchronously to check whether an error has occurred, and if an error occurs as a result of the verification, it transmits the result of the error code to the producer thread, and the result is immediately to the user through the producer thread Is transmitted, and if there is no error as a result of checking, the data may be delivered to the web application server.

The consumer thread accesses the task queue created by the producer thread through a function capable of processing the HTTP protocol and reads the data in an asynchronous manner, but the read data is already consistent with the data in the GPU and the HTTP Since at least one of an error and an error of a user input value is checked and stored in a structure, it is possible to check whether or not an error has occurred in the data by referring to the value of the structure.

The thread of the task queue created by the producer thread checks the data of the user request and, if an error occurs, stores the error occurrence and error code in a boolean structure variable, and the consumer thread refers to the value of the boolean structure variable. Thus, it is possible to check whether an error has occurred in the data.

When the task queue fails to process the user request due to a load of the CPU, the task queue may transmit wait information including a wait time and a wait sequence number to the client to guide the user.

In the method of providing web services using GPGPU-based task queues, if there is an HTTP request corresponding to the user request of the web service from the client, the HTTP server responds to a plurality of producer threads and a plurality of consumer threads. Creating a Thread); Receiving, by the HTTP server, a packet related to the HTTP request through the plurality of producer threads and transmitting the received packet to a task queue generated in a GPU; Processing, by the task queue, the HTTP request by utilizing the multi-thread processing capability of the GPGPU; Checking, by the HTTP server, whether an error has occurred with respect to the data preprocessed by the task queue through the plurality of consumer threads; And if there is no error as a result of the verification, transmitting the data to the web application server by the HTTP server.

The task queue may be processed so that a large amount of user requests does not exceed the capacity of the task queue using a circular queue algorithm.

The task queue may be implemented using CUDA based on GPGPU technology, but the CUDA thread may be implemented to perform application processing by operating like a circular queue.

The CUDA calls an HTTP packet error processing function using a kernel function to create the GPU with a plurality of threads, and the HTTP packet error processing function is a structure of task queue data defined in the kernel function and the size of the structure. By receiving as a parameter, the suitability of the packet for the HTTP request is checked, and a value is added to the error flag for return processing.

The consumer thread accesses the task queue created by the producer thread through a function capable of processing the HTTP protocol and reads the data in an asynchronous manner, but the read data is already consistent with the data in the GPU and the HTTP Since at least one of an error and an error of a user input value is checked and stored in a structure, it is possible to check whether or not an error has occurred in the data by referring to the value of the structure.

Details of other embodiments are included in the detailed description and accompanying drawings.

According to an embodiment of the present invention, by designing a task queue capable of handling a large amount of requirements using a GPGPU, a part of HTTP is processed by a GPU, thereby reducing CPU work and improving performance.

According to an embodiment of the present invention, when a user request cannot be processed due to a heavy CPU load, a waiting time and a waiting sequence number can be guided to the user in a task queue, thereby preventing the user from waiting indefinitely.

According to an embodiment of the present invention, a task queue that can utilize the multithreaded processing power of the GPGPU is developed to process user requests of web services and stores the HTTP requests in the task queue. The burden can be reduced.

According to an embodiment of the present invention, by applying a circular queue algorithm to the task queue, a request from a large number of users cannot exceed the capacity of the task queue, thereby accepting the request of a web user as a request that can be processed by the web server. You can make the server process web services more reliably.

1 is a block diagram illustrating a system for providing a web service using a GPGPU-based task queue according to an embodiment of the present invention.
2 is a flowchart illustrating a method of providing a web service using a GPGPU-based task queue according to an embodiment of the present invention.
3 is a diagram showing an example of an HTTP packet error processing function used by calling a CUDA kernel function of a GPGPU-based task queue.
4 is a diagram showing an example of implementing a producer of an HTTP server.
5 is a diagram illustrating an example of implementing a Consumer of an HTTP server.
6 is a diagram showing the performance of each experimental scenario.
7 is a diagram showing error rates of two servers (a server not using a GPGPU-based task queue and a GPGPU-based task queue server).

Advantages and/or features of the present invention, and a method of achieving them will become apparent with reference to the embodiments described later in detail together with the accompanying drawings. However, the present invention is not limited to the embodiments disclosed below, but will be implemented in a variety of different forms, only these embodiments make the disclosure of the present invention complete, and common knowledge in the technical field to which the present invention pertains. It is provided to completely inform the scope of the invention to those who have, and the invention is only defined by the scope of the claims. The same reference numerals refer to the same elements throughout the specification.

In addition, a preferred embodiment of the present invention to be implemented below is already provided in each system functional configuration in order to efficiently describe the technical components constituting the present invention, or system functions commonly provided in the technical field to which the present invention belongs. The configuration will be omitted as much as possible, and a functional configuration that should be additionally provided for the present invention will be mainly described. If a person of ordinary skill in the art to which the present invention belongs will be able to easily understand the functions of components previously used among functional configurations that are not shown below and are omitted, the configuration omitted as described above. The relationship between the elements and the components added for the present invention will also be clearly understood.

In addition, in the following description, "transmission", "communication", "transmission", "receive" of a signal or information, and other terms with similar meanings refer to direct transmission of signals or information from one component to another. Not only that, but it includes things that are passed through other components. In particular, "transmitting" or "transmitting" a signal or information to a component indicates the final destination of the signal or information and does not imply a direct destination. The same is true for "reception" of signals or information.

Hereinafter, embodiments of the present invention will be described in detail with reference to the accompanying drawings.

1 is a block diagram illustrating a system for providing a web service using a GPGPU-based task queue according to an embodiment of the present invention.

Referring to FIG. 1, a web service providing system 100 using a GPGPU-based task queue according to an embodiment of the present invention includes a task queue 110, an HTTP server 120, and a web application server 130. Can be configured.

In the consumer thread 124 of the HTTP server 120, a task queue 110 is created on the GPU using a GPGPU programming method, and C code to be executed on the GPU is also transmitted to the GPU to execute a large number of threads. Can be created with GPGPU programming method to create and manage a thread pool in the consumer thread 124 of the HTTP server 120 and to access the task queue 110 from the producer thread 122 of the HTTP server 120 Use the above GPU. Upon receiving a user request from the producer thread 122, the request may be immediately transmitted to the task queue 110.

Hereinafter, each of the components 110, 120, 122, 124, and 130 of the web service providing system 100 using a GPGPU-based task queue according to an embodiment of the present invention will be described in detail.

The task queue 110 is generated in the GPU, and may process user requests for web services by utilizing the multi-thread processing capability of the GPGPU. In this case, the task queue 110 may process the user requests generated in large quantities using a circular queue algorithm so as not to exceed the capacity of the task queue.

The task queue 110 may be implemented using a Compute Unified Device Architecture (CUDA) based on GPGPU technology. Here, the thread of the CUDA may be implemented to enable application processing by operating like a circular queue.

In addition, the CUDA may be generated by calling an HTTP packet error processing function using a kernel function. In this case, the HTTP packet error processing function may be generated in the GPU together with a plurality of threads.

The HTTP packet error processing function receives the structure of the task queue data defined in the kernel function and the size of the structure as parameters, checks the suitability of the user request of the web service, that is, the packet related to the HTTP request, and the result of the check Accordingly, you can process the return by putting a value in the Error Flag.

Meanwhile, when the task queue 110 cannot process the user request (HTTP request) due to the load of the CPU, the task queue 110 may transmit wait information including a wait time and a wait sequence number to the client. Accordingly, the user may receive information on waiting for the user request through the screen of the client (eg, PC, smartphone, etc.).

The HTTP server 120 generates a plurality of producer threads 122 and a plurality of consumer threads 124 in response to an HTTP request corresponding to the user request from a client. can do.

The HTTP server 120 may receive a packet related to the HTTP request through the plurality of producer threads 122 and transmit it to the task queue 110. In addition, the HTTP server 120 may check whether an error has occurred with respect to the data preprocessed by the task queue 110 through the plurality of consumer threads 124.

Here, the consumer thread 124 may check whether an error has occurred by reading data from the task queue 110 in an asynchronous manner.

Specifically, the consumer thread 124 may access the task queue 110 generated by the producer thread 122 through a function capable of processing the HTTP protocol and read the data in an asynchronous manner. However, the read data is already stored in the structure after checking the data consistency, HTTP error, and user input value error in the GPU. Therefore, the consumer thread 124 can check whether an error has occurred in the data by referring to the value of the structure.

In other words, the thread of the task queue 110 generated by the producer thread 122 may check the data of the user request and, if an error occurs, may store an error occurrence and an error code in a boolean structure variable. Accordingly, the consumer thread 124 can check whether an error has occurred in the data by referring to the value of the boolean structure variable.

As a result of checking whether an error has occurred, the consumer thread 124 may transmit a result of the error code to the producer thread 122 when an error occurs, and may directly transmit the result to the user through the producer thread 122. .

On the other hand, if there is no error as a result of checking whether an error has occurred, the consumer thread 124 may transmit the data to the web application server 130.

The apparatus described above may be implemented as a hardware component, a software component, and/or a combination of a hardware component and a software component. For example, the devices and components described in the embodiments include, for example, a processor, a controller, an arithmetic logic unit (ALU), a digital signal processor, a microcomputer, a field programmable array (FPA), It can be implemented using one or more general purpose computers or special purpose computers, such as a programmable logic unit (PLU), a microprocessor, or any other device capable of executing and responding to instructions. The processing device may execute an operating system (OS) and one or more software applications executed on the operating system. In addition, the processing device may access, store, manipulate, process, and generate data in response to the execution of software. For the convenience of understanding, although it is sometimes described that one processing device is used, one of ordinary skill in the art, the processing device is a plurality of processing elements and/or a plurality of types of processing elements. It can be seen that it may include. For example, the processing device may include a plurality of processors or one processor and one controller. In addition, other processing configurations are possible, such as a parallel processor.

The software may include a computer program, code, instructions, or a combination of one or more of these, configuring the processing unit to behave as desired or processed independently or collectively. You can command the device. Software and/or data may be interpreted by a processing device or to provide instructions or data to a processing device, of any type of machine, component, physical device, virtual equipment, computer storage medium or device. , Or may be permanently or temporarily embodyed in a transmitted signal wave. The software may be distributed over networked computer systems and stored or executed in a distributed manner. Software and data may be stored on one or more computer-readable recording media.

2 is a flowchart illustrating a method of providing a web service using a GPGPU-based task queue according to an embodiment of the present invention.

The web service providing method described here is only one embodiment of the present invention. In addition, various steps may be added as needed, and the following steps may also be implemented by changing the order. It is not limited to each step and the order described in the.

Referring to FIG. 2, when a client first sends a user's request to a web server (1. Http Request), the producer thread 122 of the HTTP server 120 receives the user's HTTP request and immediately receives the user's task queue 110 of the GPU. Send a packet to (2. Http Packet sending Task Queue).

Accordingly, the GPU thread stores the packet data, checks the HTTP packet error, user data error, etc., stores the contents of the error in a variable and waits.

Next, the consumer thread 124 of the HTTP server 120 asynchronously reads the data of the task queue 110 to check whether an error processed by the GPU thread has occurred (3. Http Packet Reading Task Queue).

At this time, if an error occurs in the data as a result of the check, the consumer thread 124 transmits the result of the error code to the producer thread 122, and the producer thread 122 directly transmits the result to the user ( 4. Error Packet Response).

On the other hand, if there is no error in the data as a result of the verification, the consumer thread 124 delivers the data to the web application server 130 (5. Http Packet Forwarding).

Here, the producer thread 122 is created using a TCP/IP socket server programming method. In other words, if there is an HTTP request from the client, it receives the request from the server module and immediately creates a thread. The thread pushes and stores data to the task queue 110 and waits for a response from the consumer thread 124 and the web application server 130.

Upon receiving an HTTP response from the web application server 130 (6. Http Response), the HTTP server 120 transmits a response to the client (7. Http Response) and terminates the thread.

According to an embodiment of the present invention as described above, the consumer thread 124 accesses the task queue 110 generated by the producer thread 122 through a function capable of processing the HTTP protocol, and is in an asynchronous manner. Read the data.

Since the read data is already stored in the structure where the GPU has confirmed data consistency, HTTP error, user input value error, etc., the consumer thread 124 refers to the value of the structure and causes an error in data. Immediately, an error response is sent to the producer thread 122. The producer thread 122 processes the user's response.

The thread of the task queue 110 created by the producer thread 122 checks the data of the user request and, if an error occurs, stores the error occurrence status and error code in a boolean structure variable. The consumer thread 124 checks the value of a boolean variable and, if an error occurs, immediately sends a response to the producer thread 122 along with an error code. If there is no error, the producer thread 122 transmits an HTTP packet to the web application server 130.

Meanwhile, according to an embodiment of the present invention, the consumer thread 124 creates a task queue 110 in the GPU. In order to create a large number of threads in the GPU, the consumer thread 124 creates and creates a CUDA (Compute Unified Device Architecture) application, and creates and waits for a thread to receive data of a user request in an asynchronous manner in the GPU.

When the consumer thread 124 receives a user request from the task queue 110, the consumer thread 124 checks an error code and immediately reports an error to the producer thread 122 if an error occurs. On the other hand, if there is no error, the consumer thread 124 transmits data to the web application server 130 to process a user request. The response to the user request processed by the web application server 130 is transmitted to the user by the producer thread 122.

System implementation

Implement GPGPU based task queue using CUDA. In addition, the task queue algorithm uses the circular queue algorithm, and the CUDA thread works like a circular queue to enable simple application processing.

3 is a diagram showing an example of an HTTP packet error processing function used by calling a CUDA kernel function of a GPGPU-based task queue.

Referring to FIG. 3, an HTTP packet error processing function is called from a kernel function of CUDA and is generated in a GPU with a large number of threads. Receives the task_queue_data structure defined in the CUDA kernel function and the size of the structure as parameters, checks the suitability of the HTTP packet, and returns the error_flag value.

Implemented HTTP server Producer and Consumer server. Producer server receives user's request and transmits data to task queue. Consumer server reads user's data from task queue, handles error and transmits user's request to web application. As shown in FIG. 3, the Producer server is a multi-threaded server that receives an HTTP request from a user client, separates and stores data to be processed in a task_queue_data structure and transmits it to a task queue.

Producer server receives HTTP Request packet from client. Http Request data is separated and stored in a structure from the original HTTP Request data, and the user input data is separated and stored in the user's http_user_data structure. When each data is stored in a structure like this, the structure of task_queue is completed, and the structure of task_queue is pushed to the GPGPU task queue.

Producer shares the shared_mem structure stored in shared memory in order to share the rear value of the task queue with the consumer. As shown in Figure 4, the HTTP server Producer was implemented. The structure of the consumer server first initializes the shared memory to read the front information of the task queue from the shared memory. Next, it reads the data from the task queue and checks the error_flag. If there is no error in the data, it forwards the HTTP Request to the web application server (WAS).

The reason for the simple thread structure of the consumer server is that the consumer server can send data to the WAS server immediately after checking an error by executing a program for data processing in the task queue of the GPU. Therefore, we implemented a consumer server with a simple thread structure.

Consumer server is a multi-threaded server program that implements a function that reads data from a task queue, checks data errors, and transmits it to a web application server to process user requests. As shown in FIG. 5, a Consumer of an HTTP server was implemented.

Experiment Scenario and Experiment Results

In the experiment, three scenarios were selected and the experiment was conducted in the same way for the server not using the GPGPU-based task queue and the GPGPU-based task queue server.

Scenario 1 conducted an experiment to test the processing speed of a server that did not use a GPGPU-based task queue and a GPGPU-based task queue in a stable service.

In Scenario 2, 1,000 threads were created in a short time and 3,000 HTTP Requests were requested. This experiment is an experiment that can compare both stability and performance.

Scenario 3 tested the stability and speed of both servers by generating a large number of threads. An experiment was conducted to confirm the server down phenomenon by generating a total of 9,000 HTTP Requests.

6 is a diagram showing the performance of each experimental scenario.

Referring to FIG. 6, when the performance of the two servers is compared, a difference (improvement) of about 2 to 1.3 times can be seen.

When the number of threads is small, there is a large difference in performance in HTTP Request, and as the number of threads increases and the number of HTTP Requests increases, the speed difference between the two servers decreases. When a large number of threads are generated between the server that does not use the GPGPU-based task queue and the GPGPU-based task queue server, the performance between the two servers gradually becomes similar. This is a slowdown phenomenon that occurs when a large amount of data is copied from the CPU to the GPU in the GPGPU-based task queue server.

The GPGPU-based task queue server uses the Peripheral Component Interconnect (PCI) Express interface to copy data from the CPU to the GPU. This is a phenomenon that occurs because the speed of the PCI Express interface is slow. If you increase the speed of data copying between the CPU and GPU, you can reduce the slowdown caused by an increase in HTTP requests.

7 is a diagram showing error rates of two servers (a server that does not use a GPGPU-based task queue and a GPGPU-based task queue server).

Referring to FIG. 7, in scenario 1, both servers are stably processing HTTP Requests. Scenario 1 is an experiment to check the performance, and general HTTP Request processing does not cause an error.

In scenario 2, an error of 2.43% occurred on the server that did not use the GPGPU-based task queue. When a large number of threads were created in a short time and HTTP Request was requested, the request was rejected. On the other hand, in the case of a GPGPU-based task queue server, all HTTP requests were processed stably.

Scenario 3 requested more threads and HTTP Request than scenario 2. In the case of servers that did not use the GPGPU-based task queue, an error rate of 15.4% occurred. However, there was no server down phenomenon, and the rest of HTTP Request was processed normally. On the other hand, all GPGPU-based task queue servers were able to process HTTP Requests.

As shown in FIGS. 6 and 7, it can be seen that the GPGPU-based task queue server is superior to the server that does not use the GPGPU-based task queue in terms of performance and stability.

As described above, in an embodiment of the present invention, a GPGPU-based task queue is implemented using NVIDIA's CUDA for processing a large amount of requests for web services and for the safety of a web server.

The experimental results of the present invention can be seen that the performance of the server using the GPGPU-based task queue is improved from 136% to 233% compared to the performance of the server not using the GPGPU-based task queue. It was shown that the GPU, which is widely used in artificial intelligence, games, and high-performance scientific and technological calculations, can be used to improve the performance of general applications.

In order to process a large amount of user requests with the configuration of the existing web service, a lot of costs are incurred when the performance of the web server is improved or if a number of web servers are installed and operated. However, in the case of using the GPGPU-based task queue presented in the present invention, when a GPU is installed and utilized in the server when processing a large number of user requests in one server, a more stable and high-performance web service can be provided at low cost. have.

In addition, if the GPGPU-based task queue server provides multiple GPUs capable of handling more HTTP requests, it is expected that the performance of the web server can be further improved. In other words, when there is a large number of user requests to the existing web service, it is expected that the problem of web service interruption can be solved at low cost by utilizing the GPU.

GPGPU is widely used in the field of HPC, games, simulation, and artificial intelligence, and the number is increasing. Many tasks are performed using the GPU, and the fields of use of the GPU are also developing in various ways.

The latest GPUs provide high-performance floating-point arithmetic functions that support not only graphics processing but also GPGPU programs. In addition, its performance continues to evolve so that it can create and process a large number of threads. If the GPU continues to evolve so that the performance of this GPU can be used in general applications, and the GPU assists the CPU to develop, the execution performance of general-purpose applications improves, and the hardware for executing high-performance general-purpose applications can further reduce costs. have.

The method according to the embodiment may be implemented in the form of program instructions that can be executed through various computer means and recorded in a computer-readable medium. The computer-readable medium may include program instructions, data files, data structures, and the like alone or in combination. The program instructions recorded on the medium may be specially designed and configured for the embodiment, or may be known and usable to those skilled in computer software. Examples of computer-readable recording media include magnetic media such as hard disks, floppy disks, and magnetic tapes, optical media such as CDROMs and DVDs, and magnetic-optical media such as floptical disks. And hardware devices specially configured to store and execute program instructions such as magneto-optical media, and ROM, RAM, flash memory, and the like. Examples of the program instructions include not only machine language codes such as those produced by a compiler, but also high-level language codes that can be executed by a computer using an interpreter or the like. The hardware device described above may be configured to operate as one or more software modules to perform the operation of the embodiment, and vice versa.

As described above, although the embodiments have been described by the limited embodiments and drawings, various modifications and variations are possible from the above description by those of ordinary skill in the art. For example, the described techniques are performed in a different order from the described method, and/or components such as a system, structure, device, circuit, etc. described are combined or combined in a form different from the described method, or other components Alternatively, even if substituted or substituted by an equivalent, an appropriate result can be achieved.

Therefore, other implementations, other embodiments, and equivalents to the claims fall within the scope of the following claims.

110: task queue
120: HTTP server
122: Producer thread
124: Consumer thread
130: web application server

Claims (13)

A task queue that is created in the GPU and processes a user request for a web service by utilizing the multi-thread processing capability of the GPGPU; And
When there is an HTTP request corresponding to the user request from a client, a plurality of producer threads and a plurality of consumer threads are generated in response to the HTTP request, and the HTTP request is responded to through the plurality of producer threads. When the task queue receives a packet related to and transmits it to the task queue, the task queue is preprocessed so that the data of the packet related to the HTTP request generated in large quantities does not exceed the capacity of the task queue using a circular queue algorithm HTTP server that checks whether an error occurs in the preprocessed data through the plurality of consumer threads for the data preprocessed by and, if there is no error, delivers the data to the web application server
A web service providing system using a GPGPU-based task queue, comprising: a.
delete The method of claim 1,
The task queue is
A web service providing system using a GPGPU-based task queue, which is implemented using a GPGPU technology-based CUDA (Compute Unified Device Architecture).
The method of claim 3,
The CUDA is
An HTTP packet error processing function is called using a kernel function to create the GPU with a plurality of threads, and the HTTP packet error processing function takes a structure of the task queue data defined in the kernel function and the size of the structure as parameters. A web service providing system using a GPGPU-based task queue, characterized in that, receiving and checking the suitability of the packet for the HTTP request, putting a value in an error flag and processing the return.
The method of claim 1,
The consumer thread is
The data preprocessed by the task queue is read asynchronously to check whether an error has occurred, and if an error occurs as a result, the result of the error code is transmitted to the producer thread and the result is immediately sent to the user through the producer thread. A web service providing system using a GPGPU-based task queue, characterized in that the data is transmitted to the web application server when there is no error as a result of the transmission.
The method of claim 1,
The consumer thread is
Through a function capable of processing the HTTP protocol, the task queue created by the producer thread is accessed and the preprocessed data is read asynchronously, but the read data is already in the GPU for data consistency, HTTP error, A web service providing system using a GPGPU-based task queue, characterized in that since at least one of the errors of a user input value is checked and stored in a structure, the error of the data is checked by referring to the value of the structure.
The method of claim 6,
The thread of the task queue created by the producer thread is
If an error occurs by checking the data of the user request, the error and error code are stored in a boolean structure variable.
The consumer thread is
A web service providing system using a GPGPU-based task queue, characterized in that checking whether an error has occurred in the preprocessed data by referring to the value of the boolean structure variable.
The method of claim 1,
The task queue is
A web service providing system using a GPGPU-based task queue, characterized in that, when the user request cannot be processed due to a CPU load, waiting information including a waiting time and a waiting sequence number is transmitted to a client to guide the user.
Generating, by the HTTP server, a plurality of producer threads and a plurality of consumer threads in response to an HTTP request corresponding to a user request of a web service from a client;
Receiving, by the HTTP server, a packet related to the HTTP request through the plurality of producer threads and transmitting the packet to a task queue generated in a GPU;
Processing the HTTP request by the task queue using the multi-thread processing capability of the GPGPU;
When the task queue is preprocessed so that the data of the packet related to the HTTP request generated in a large amount using a circular queue algorithm does not exceed the capacity of the task queue, the HTTP server is reminded of the data preprocessed by the task queue. Checking whether an error has occurred in the preprocessed data through a plurality of consumer threads; And
If there is no error as a result of checking, the HTTP server transferring the preprocessed data to a web application server
Web service providing method using a GPGPU-based task queue comprising a.
delete The method of claim 9,
The task queue is
A method of providing a web service using a GPGPU-based task queue, which is implemented using CUDA based on GPGPU technology.
The method of claim 11,
The CUDA is
An HTTP packet error processing function is called using a kernel function to create the GPU with a plurality of threads, and the HTTP packet error processing function takes a structure of the task queue data defined in the kernel function and the size of the structure as parameters. A method of providing a web service using a GPGPU-based task queue, characterized in that receiving a packet, checking the suitability of the packet for the HTTP request, putting a value in an error flag, and processing the return.
The method of claim 9,
The consumer thread is
Through a function capable of processing the HTTP protocol, the task queue created by the producer thread is accessed and the preprocessed data is read asynchronously, but the read data is already in the GPU for data consistency, HTTP error, Since at least one of the errors of user input values is checked and stored in a structure, the method of providing a web service using a GPGPU-based task queue, characterized in that it checks whether an error occurs in the preprocessed data by referring to the structure value.

Images