JP2022522609A - How to execute user code of programming platform and platform, node, device, medium - Google Patents

Abstract

This application discloses a method of executing a user code of a programming platform and a platform, a node, a device, and a medium. Here, the programming platform includes a service node, a task queue, and a compute node. In the above method, the service node acquires a user code for representing a user terminal and registers the user code in the task queue as an execution task. That, the compute node monitors the task queue and gets the execution task, the compute node calculates the execution task and gets the computation result, and the service node gets the computation result from the compute node. And feed back the calculation result to the user terminal. [Selection diagram] Fig. 1

Description

This application is submitted on the basis of a Chinese patent application with an application number of 20200093681.6 filed with the Chinese Patent Office on February 14, 2020, claiming the priority of the Chinese patent application. The entire contents of the Chinese patent application are incorporated herein by reference.

This application relates to the field of programming technology, and more particularly to the method of executing user code of a programming platform and the platform, node, device, medium.

With the rapid development of artificial intelligence, various systems that rely on code operations are emerging. Not only is the code becoming more diverse, but it also imposes ever-increasing requirements on the functionality that the system can provide.

In the face of increasingly complex code, in today's programming platforms, code execution environments such as the Kernel (execution environment) typically maintain connectivity with the user terminal and are issued by the user terminal. As a result, the system power cannot meet the code execution requirements.

In view of the above circumstances, how to improve the concurrency of the programming platform that executes the user code has become an urgent issue to be solved.

The present application provides a method of executing a user code of a programming platform and a platform, a node, a device, and a medium.

The programming platform according to the present application includes a service node, a task queue, and a calculation node. A first aspect of the present application provides a method of executing a user code of a programming platform, wherein the service node acquires a user code for representing a user terminal, and the user code is used as an execution task. To register in the queue, to monitor the task queue and acquire the execution task, and to have the calculation node calculate the execution task and acquire the calculation result. The service node acquires the calculation result from the calculation node and feeds back the calculation result to the user terminal.

Therefore, the service node realizes the connection with the user terminal and registers the user code in the queue, and the calculation node calculates the user code, thereby realizing the execution of the user code. Since the service node and the calculation node are installed separately during the execution of the above user code, the connection of the user terminal and the calculation of the user code are completed by the service node and the calculation node, respectively, and asynchronous communication of the execution of the user code is performed. Realize and improve the simultaneous execution capacity of the system.

Here, the number of the calculation nodes is at least two, and the calculation node monitors the task queue to acquire the execution task, that is, at least two calculation nodes monitor the task queue. However, the task queue includes requesting the task queue to acquire the execution task, and the task queue allocates one execution task to one calculation node.

Therefore, if multiple compute nodes monitor one execution task in a task queue, all the compute nodes request the task queue to get the execution task, and the task queue has one execution task. By assigning to a compute node, you can complete the rational allocation of executed tasks via the task queue.

Here, the task queue includes a first task queue and a second task queue, and at least two of the calculation nodes include a first calculation node and a second calculation node, and the user code is used as an execution task in the task queue. Registration includes registering the user code in the first task queue or the second task queue as an execution task according to the calculation feature of the user code, and the calculation node monitoring the task queue. The first compute node monitors the first task queue, and the second compute node monitors the second task queue.

Therefore, the service node can distinguish user codes based on the computational characteristics of the user code and register them in the first task queue or the second task queue, respectively, so that different compute nodes monitor different task queues. It is then possible to process the user code in different ways depending on the various execution requirements of the user code.

Here, the number of the service nodes is at least two, and when the service node acquires a user code for representing a user terminal, the service nodes are assigned via the reverse proxy. Includes getting a user code.

Therefore, the present application can provide at least two service nodes, which obtain a user code assigned via a reverse proxy, thereby a user issued by a user terminal by a plurality of service nodes. It is possible to receive the code and improve the concurrency processing capacity.

Here, after the calculation node completes the calculation of the execution task, it releases the corresponding calculation resource and continues to monitor the task queue.

Therefore, the compute node releases resources as soon as it completes the computation and continues to monitor the task queue to get new execution tasks. Since the compute node releases the resource immediately after completing the execution of the execution task, the compute resource and the memory resource are reused, and the hardware resource can be sufficiently and rationally used.

Here, the programming platform further includes a message queue, and the calculation node obtains the calculation result from the calculation node and feeds back the calculation result to the user terminal. This includes registering the result in the message queue, the service node monitoring the message queue, acquiring the calculation result, and feeding back the calculation result to the user terminal.

Therefore, after the calculation node completes the execution of the execution task corresponding to any user code, the calculation result is uniformly registered in the message queue, and the service node monitors the message queue to calculate the calculation result of the calculation node. Can be obtained, so the calculation results can be managed uniformly.

Here, the service node maintains a session connection with the user terminal until the calculation result is acquired.

Therefore, the service node always maintains a session connection with the user terminal until the calculation result is acquired, that is, maintains a connection between the service node and the user terminal, and feeds back the calculation result to the user terminal. It is convenient for.

A second aspect of the present application provides a method of executing a user code of a programming platform, wherein the method obtains a user code for representing a user terminal and a compute node obtains an execution task from a task queue. The user code is registered in the task queue as the execution task so as to be calculated, and the calculation result of the calculation node is acquired and the calculation result is fed back to the user terminal.

Therefore, the service node is configured to connect to the user terminal and register the user code issued by the user terminal in the task queue as an execution task, whereby the compute node independent of the service node is executed from the task queue. After acquiring the calculation result by acquiring and calculating, the service node acquires the calculation result of the calculation node and feeds back the calculation result to the user terminal to realize the execution of the user code.

Here, registering the user code as the execution task in the task queue so that the calculation node can acquire the execution task from the task queue and calculate the execution task executes the user code according to the calculation characteristics of the user code. By registering it in the first task queue or the second task queue as a task, the first calculation node can acquire the execution task from the first task queue and calculate it, or the second calculation node can calculate the first task queue. 2 It includes acquiring the execution task from the task queue and making it possible to calculate.

Therefore, the service node can distinguish user codes based on the computational characteristics of the user code and register them in the first task queue or the second task queue, respectively, so that different compute nodes monitor different task queues. It is then possible to process the user code in different ways depending on the various execution requirements of the user code.

Here, acquiring the user code for representing the user terminal includes acquiring the user code assigned via the reverse proxy.

Therefore, the service node obtains the user code assigned via the reverse proxy, whereby the service node can reasonably assign the user code issued by the user terminal.

Here, the method includes maintaining a session connection with the user terminal until the calculation result is acquired.

Therefore, the service node always maintains a session connection with the user terminal until the calculation result is acquired, that is, maintains a connection between the service node and the user terminal, and feeds back the calculation result to the user terminal. It is convenient for.

A third aspect of the present application provides a method of executing a user code of a programming platform, wherein the method is to monitor a task queue and acquire an execution task, wherein the task queue includes the execution task. , The execution task includes corresponding to the user code, calculating the execution task, and acquiring the calculation result.

Therefore, since the task queue includes the execution task and the execution task corresponds to the user code, the compute node monitors the task queue including the execution task, acquires the execution task corresponding to the user code, and performs the execution task. By calculating and acquiring the calculation result, the execution task is acquired and the calculation is realized.

Here, the method of executing the user code of the programming platform includes releasing the corresponding calculation resource and continuing to monitor the task queue after completing the calculation of the execution task.

Therefore, the compute node releases resources immediately after completing the computation, keeps an eye on the task queue to get new execution tasks, executes user code on different compute nodes, and compute nodes of the execution task. Since the resources are released immediately after the execution is completed, the computational resources and the memory resources are reused, and the hardware resources can be used sufficiently and rationally.

A fourth aspect of the present application provides a programming platform, which comprises a service node, a task queue, and a compute node, wherein the service node obtains a user code for representing a user terminal, and the user. The code is configured to register the code as an execution task in the task queue, the compute node is configured to monitor the task queue and acquire the execute task, and the compute node further configures the execute task. It is configured to calculate and acquire the calculation result, and the service node is further configured to acquire the calculation result from the calculation node and feed back the calculation result to the user terminal.

Here, the number of the calculation nodes is at least two, and when the calculation nodes are configured to monitor the task queue and acquire the execution task, the at least two calculation nodes are the tasks. The task queue is configured to monitor the queue and request the task queue to acquire the execution task, and the task queue is configured to allocate one execution task to one compute node.

Here, the task queue includes a first task queue and a second task queue, at least two of the compute nodes include a first compute node and a second compute node, and the service node executes the user code. When configured to be registered in the task queue as a task, specifically, the service node registers the user code in the first task queue or the second task queue as an execution task according to the calculation characteristics of the user code. When configured as such, the compute node is configured to monitor the task queue, specifically, the first compute node is configured to monitor the first task queue and the second compute node. Is configured to monitor the second task queue.

Here, the number of the service nodes is at least two, and when the service nodes are configured to acquire a user code for representing a user terminal, the at least two service nodes are connected via a reverse proxy. It is configured to acquire the assigned user code.

Here, the calculation node is configured to release the corresponding calculation resource and continue to monitor the task queue after completing the calculation of the execution task.

Here, if the programming platform further includes a message queue and the service node is configured to acquire the calculation result from the calculation node and feed the calculation result back to the user terminal, the calculation node is configured. , The service node is configured to monitor the message queue, acquire the calculation result, and feed back the calculation result to the user terminal. ..

Here, the service node is further configured to maintain a session connection with the user terminal until the calculation result is acquired.

A fifth aspect of the present application provides a service node, wherein the service node includes a receiving unit, a registration unit, and an acquisition unit, and the receiving unit is configured to acquire a user code for representing a user terminal. The registration unit is configured to register the user code as the execution task in the task queue so that the calculation node can acquire the execution task from the task queue and calculate it, and the acquisition unit is the calculation node. It is configured to acquire the calculation result and feed back the calculation result to the user terminal.

Here, the registration unit is configured to register the user code as the execution task in the task queue so that the compute node can acquire the execution task from the task queue and calculate it, and the registration unit is further configured. By registering the user code as an execution task in the first task queue or the second task queue according to the calculation feature of the user code, the first calculation node can acquire the execution task from the first task queue and calculate. Or it is configured to allow the second compute node to acquire and compute the execution task from the second task queue.

Here, the receiving unit is configured to acquire a user code for representing a user terminal, and the receiving unit is further configured to acquire the user code assigned via a reverse proxy.

Here, the service node is configured to maintain a session connection with the user terminal until the acquisition unit acquires the calculation result.

A sixth aspect of the present application provides a calculation node, wherein the calculation node includes a monitoring unit and a calculation unit, and the monitoring unit is configured to monitor a task queue and acquire an execution task. Includes the execution task, the execution task corresponds to the user code, and the calculation unit is configured to calculate the execution task and obtain a calculation result.

Here, the calculation unit is further configured to release the corresponding calculation resource and continue to monitor the task queue after completing the calculation of the execution task.

A seventh aspect of the present application provides an electronic device, wherein the electronic device comprises a memory and a processor coupled to each other, and the processor executes a program instruction stored in the memory. The method of executing the user code of the programming platform in the first aspect of the above, and / or the method of executing the user code of the programming platform in the second aspect of the above, and / or the user of the programming platform in the third aspect of the above. It is configured to implement how the code is executed.

Therefore, the service node is configured to provide a connection to the user terminal and queue the user code, and the compute node is configured to compute the user code, thereby achieving the execution of the user code. do. Since the service node and the calculation node are installed separately during the execution of the above user code, the connection of the user terminal and the calculation of the user code are completed by the service node and the calculation node, respectively, and asynchronous communication of the execution of the user code is performed. Realize and improve the simultaneous execution capacity of the system.

Eighth aspect of the present application provides a computer-readable storage medium in which program instructions that can be executed by a processor are stored, and the program instructions are the method of executing the user code of the programming platform in the first aspect described above, and / or. It is used to realize the method of executing the user code of the programming platform in the second aspect described above and / or the method of executing the user code of the programming platform in the third aspect described above.

Therefore, during the execution of the user code described above, the service node is configured to implement the connection with the user terminal, the compute node is configured to implement the computation of the user code, and asynchronous communication of the execution of the user code. And improve the simultaneous execution capacity of the system.

The drawings herein are incorporated herein to constitute a portion thereof, and these drawings are intended to show examples consistent with the present application and to illustrate the technical solutions of the embodiments of the present application together with the specification. Used for.
It is a schematic diagram of the implementation process of the execution method of the user code of the programming platform which concerns on embodiment of this application. It is a schematic diagram of another implementation process of the method of executing the user code of the programming platform according to the embodiment of the present application. It is a schematic diagram of yet another implementation process of the method of executing the user code of the programming platform according to the embodiment of the present application. It is a schematic structural diagram of the programming platform which concerns on embodiment of this application. It is a schematic structural diagram of the service node 41 of the programming platform which concerns on embodiment of this application. It is a schematic structural diagram of the calculation node 43 of the programming platform which concerns on embodiment of this application. It is another schematic structure diagram of the programming platform which concerns on embodiment of this application. It is a schematic diagram of the framework of the electronic device which concerns on embodiment of this application. It is a schematic diagram of the framework of the storage device which concerns on embodiment of this application.

Hereinafter, various exemplary examples, features, and embodiments of the embodiments of the present application will be described in detail with reference to the drawings. The same reference number in the drawing indicates an element of the same or similar function. Various embodiments of the examples are shown in the drawings, but it is not necessary to draw the drawings to scale unless otherwise specified.

Hereinafter, the technical solution of the embodiment of the present application will be described in detail with reference to the drawings.

Hereinafter, the technical solution in the embodiment of the present application will be clearly and completely described with reference to the drawings in the embodiment of the present application. It will be clear that it is not. All other examples obtained by one of ordinary skill in the art based on the examples of the present application without creative effort are included in the scope of protection of the present application. The terms "first" and "second" herein are used for illustration purposes only and imply a number of technical features that indicate or imply relative importance. It should not be understood as being shown in.

In some examples, with the spread of artificial intelligence, machine learning and artificial intelligence programming education are gradually becoming an important part of programming education. Unlike traditional introductory programming education, artificial intelligence code executed by students in artificial intelligence programming education usually requires a large amount of computation and the corresponding resource overhead (eg, central processing unit (CPU)). / Graphics processing unit (GPU: Graphics Processing Unit) occupancy rate, memory space, etc.) is also large. In the programming education platform of the related technique, one independent kernel is created for each user and stored in the server memory, so that each user can execute a programming experiment with the created independent kernel. As described above, since the resource overhead required for the artificial intelligence code is large, each kernel occupies a large amount of CPU / GPU resources and memory space, and when the kernel of each user resides in the memory, the overall overhead is large. Resource utilization is low. Further, since each user and the kernel have a strict one-to-one correspondence, the number of users who can execute online programming learning at the same time is limited to the number of kernels that the server can support. Since the runtime environment of each user's Kernel process does not change, it is not possible to flexibly schedule and execute them on different machines according to the resource occupancy status of the user code, which is an unreasonable resource when a multi-machine is deployed. Allocations are prone to occur and do not help improve the concurrency of the system. In this way, in the online programming education of artificial intelligence, the cost of the server rises sharply, and it becomes difficult to advertise and spread it.

In view of the above circumstances, the embodiments of the present application provide a method of executing user code of a programming platform, and after the user submits the code by constructing an equal set of service nodes and an equal set of compute nodes. , Websocket (Protocol of full-duplex communication) technology is used to transmit the user code to any service node. The service node creates one execution task, puts it in the task queue, maintains the current session connection, and any compute node gets the execution task from the task queue and then executes the user code. The execution result is fed back to the corresponding service node in real time via the task queue, and then the compute node immediately releases the resource. The service node reads the execution result from the task queue, pushes it back to the user terminal in real time via the protocol of full-duplex communication, and ends the current session after the push is completed. Here, the service node supports multitasking simultaneous connection, and the compute node supports singletask execution.

The implementation process of the method is shown in FIG. 1, and FIG. 1 is a schematic diagram of the implementation process of the user code execution method of the programming platform according to the embodiment of the present application. Specifically, the method of the present embodiment includes the following steps.

In step S101, the service node acquires a user code for representing the user terminal and registers the user code in the task queue as an execution task.

The programming platform according to the embodiment of the present application includes a service node, a task queue, and a calculation node.

The service node can acquire the user code of any of the plurality of user terminals, can acquire the user code of the plurality of user terminals at the same time, and can support the simultaneous connection of the plurality of user terminals. A service node can be realized by any electronic device having processing power such as a server or a computer. Here, the electronic device can also be used to perform other functions. For example, the electronic device is further configured to perform the computation of the execution task acquired by the compute node, i.e., the service node and the compute node can be realized by the same electronic device or different electronic devices. The method of receiving the user code by the service node includes, but is not limited to, a method of receiving by the websocket communication technology and the hypertext transfer protocol (HTTP) communication technology, but is not particularly limited here. .. The source of the user code received by the service node can be diversified, for example, the code edit window of the user terminal itself can be used to acquire the code edited by the user to form the user code, or the user terminal is connected to it. Receives the user code transmitted by the code editing device.

In the embodiment of the present application, the number of service nodes is at least two. When the service node acquires the user code for representing the user terminal, at least two service nodes acquire the user code assigned via the reverse proxy. These service nodes serve the front-end application, the front-end application and the service node communicate using the full-duplex communication protocol, and the service node is the user terminal assigned by the reverse proxy server. The user code is received, and here, the user code of the user terminal represents the identification information of the user terminal. For example, the user code of the user terminal indicates the serial number of the user terminal, the user account of the user terminal, or the like. A reverse proxy server is used to achieve the allocation of user code between the user terminal and at least two service nodes, and if the reverse proxy server gets the user code of the user terminal, the user code is at least two service nodes. Can be assigned to, which allows each service node to retrieve the user code assigned via the reverse proxy. Similarly, the service node can receive the user codes of a plurality of user terminals at the same time and can port the simultaneous connection of the plurality of user terminals.

After receiving the user code, the service node creates one execution task for each user code and registers the execution task in the task queue. Thereby, the task queue contains the execution task registered by the service node and having a one-to-one correspondence with the user code. The queuing queue can be a storage system such as a Remote Dictionary Service (Redis) list, or message-oriented middleware such as RabbitMQ (Message Queuing).

In the embodiment of the present application, the execution task corresponding to the user code is separately registered according to the resource dependency requirement of the user code. Specifically, the task queue includes a first task queue and a second task queue, and depends on different code resources when the execution tasks in the first task queue and the second task queue are calculated. For example, the execution task in the first task queue depends on the CPU code execution environment resource, and the execution task in the second task queue depends on the GPU code execution environment resource. The allocation of execution tasks in the first task queue and the second task queue depends on the computational feature of the user code, i.e., the computational feature indicates that the user code belongs to the first task queue or the second task queue. Used for. Here, the representation format of the calculation feature includes, but is not limited to, a character string identifier of a preset bit length in the user code, a binary code, and the like. As a result, when the service node registers the user code as an execution task in the task queue, the user code is registered in the first task queue or the second task queue as an execution task according to the calculation characteristics of the user code.

In the embodiment of the present application, the task queue may include at least two subtask queues, and the relationship between the service node and the plurality of subtask queues can be established in advance, and the service node represents a user terminal. Obtain the user code and register the user code as an execution task in different subtask queues, or establish a relationship between multiple service nodes and multiple subtask queues, and some of the service nodes are the receiving users. Registering the code in one part of the subtask queue that has been associated with them, and another part of the service node registering the received user code in another part of the subtask queue that has been associated with them. Allows the corresponding association between the service node and the task queue to be realized.

In step S102, the compute node monitors the task queue and acquires the execution task.

The task queue includes an execution task, and the compute node can monitor the task queue and acquire the execution task when it detects that the execution task that can be executed by the compute node is included in the task queue. In the method in which the compute node retrieves the execution task from the task queue, the task queue actively assigns the execution task to the compute node, or the compute node requests the task queue to retrieve the execution task, and the task queue makes the request. Includes, but is not limited to, assigning execution tasks to compute nodes accordingly.

In the embodiment of the present application, the number of calculation nodes is at least two. When a compute node monitors a task queue and retrieves an execution task, at least two compute nodes monitor the task queue and request the task queue to retrieve the execution task, and the task queue is one execution task. Is assigned to one compute node, whereby the task queue completes the rational allocation of execution tasks. The rules for assigning tasks executed by the task queue to compute nodes can be customized. For example, if the priority of all compute nodes is stored in advance and the task queue receives a request to acquire the same execution task from multiple compute nodes, the execution task is assigned to the compute node with higher priority. Alternatively, the execution task is assigned to the calculation node having the smallest number of execution tasks acquired within the preset time, and is not particularly limited here.

In the embodiment of the present application, when the task queue includes the first task queue and the second task queue, and the compute node includes the first compute node and the second compute node, it is specific that the compute node monitors the task queue. The first compute node monitors the first task queue and the second compute node monitors the second task queue, so that different compute nodes monitor and manage different task queues, respectively. It becomes easy and improves the acquisition efficiency of the execution task. Here, the first calculation node and the second calculation node are arranged in servers having different configurations, whereby they have different calculation resources and memory resources, and can realize calculation of different user codes. In the case of user code calculation, according to the calculation feature, the calculation resource and memory resource that depend on when the user code is calculated can be known, that is, the calculation feature of the user code is that the user code is the first task queue or the first task queue. 2 In order to indicate that it belongs to the task queue, it is instructed that the user code is calculated by the first calculation node or the second calculation node on the server having a different configuration.

Further, the first calculation node is installed in the CPU server, the second calculation node is installed in the GPU server, the first task queue includes an execution task depending on the CPU code execution environment resource, and the second task queue is. It contains an execution task that depends on the GPU code execution environment resource, so that the first compute node of the CPU server monitors the first task queue and acquires the execution task, and the second compute node of the GPU server is the second. Monitor the task queue and get the executed task.

In step S103, the calculation node calculates the execution task and acquires the calculation result.

The calculation node can acquire the calculation result by calculating the acquired execution task by using the calculation resource and the memory resource available in the deployed server. After completing the calculation of the execution task, the compute node releases the corresponding compute resource and continues to monitor the task queue. That is, the compute node maximizes compute and memory resources because it releases resources after it completes the calculation of the current execution task and continues to monitor the task queue to get new execution tasks. Can be reused. Here, in the present application, whether the calculation node acquires an arbitrary execution task in the task queue, or the first calculation node and the second calculation node acquire the execution task in the first task queue and the second task queue, respectively. Regardless of, the same compute node completes the execution task and frees resources, continuously performing new execution tasks as long as the compute node's compute and memory resources comply with the user code's execution environment resources. Can be obtained. Therefore, since the user code can be executed on different compute nodes, the compute resources and memory resources of the compute node can be reused, and the hardware resources of the server can be sufficiently and rationally used.

As described above, the service node registers the user code as an execution task in the first task queue or the second task queue according to the calculation characteristics of the user code, and the first calculation node and the second calculation node are each the first task. The execution task is acquired from the queue and the second task queue, and the first calculation node and the second calculation node of the servers having different configurations calculate the execution task using the respective calculation resources and memory resources, and calculate the calculation result. get. Therefore, the task queue performs the assignment of execution tasks to compute nodes according to the actual needs of the user code, which belong to servers of different configurations, thereby achieving rational use of resources. do. For example, the first task queue is a CPU task queue, the second task queue is a GPU task queue, the first compute node and the second compute node are located on the CPU server and the GPU server, respectively, and the first compute node is. , The execution task is acquired from the first task queue and calculated, and the second calculation node acquires the execution task from the second task queue and calculates. Specifically, when the calculation feature of the user code indicates that the corresponding user code belongs to the first task queue, the first calculation node acquires the execution task from the first task queue and calculates the CPU server. Calculate the execution task using resources and memory resources, and get the calculation result. Computation nodes on the CPU server can execute traditional code that does not depend on GPU server resources, and compute nodes on the GPU server use code that uses GPU server resources (eg, training of neural network models and image processing). Etc., but not limited to these).

In step S104, the service node acquires the calculation result from the calculation node and feeds back the calculation result to the user terminal.

After the calculation node calculates the execution task and acquires the calculation result, the service node acquires the calculation result from the calculation node and feeds back the calculation result to the user terminal. The method in which the service node acquires the calculation result from the calculation node includes, but is not limited to, a method of acquiring the calculation result via an acquisition request, subscription, or the like, and is not particularly limited here. When the service node acquires the calculation result from the calculation node via the acquisition request, the service node monitors the calculation node and sends an acquisition request to acquire the calculation result to the calculation node. The corresponding calculation node feeds back the calculation result to the service node in response to the acquisition request. When the service node obtains the calculation result from the calculation node via the subscribe, the calculation node calculates the execution task and obtains the calculation result, and then directly transfers the calculation result to the service node. Give feedback to.

In an embodiment of the present application, the programming platform further includes a message queue, which is used to temporarily store the calculation result acquired by the compute node computing the execution task. The message queue can be a storage system such as a Redis list, or message-oriented middleware such as RabbitMQ. When the message-oriented service node acquires the calculation result from the calculation node and feeds back the calculation result to the user terminal, the calculation node registers the calculation result in the message queue, and the service node monitors the message queue and the calculation result. And feed back the calculation result to the user terminal. When the service node acquires the calculation result from the calculation node and feeds back the calculation result to the user terminal, the service node subscribes the calculation result of the calculation node from the message queue and outputs the calculation result by communication technology such as webbooket. Give feedback to the user terminal.

In the embodiment of the present application, the service node establishes a session connection with the user terminal after acquiring the user code for representing the user terminal, and the service node establishes a session connection with the user terminal until the calculation result is acquired. Maintaining, the service node disconnects the session connection with the corresponding user terminal after acquiring the calculation result of the compute node. As a result, the service node maintains the connection between the service node and the user terminal until the calculation result is acquired, and facilitates feedback of the calculation result to the user terminal. Since the service node and the calculation node are installed separately during the execution of the user code, the connection of the user terminal and the calculation of the user code are completed by the service node and the calculation node, respectively. Here, while the service node maintains a session connection with the user terminal, the compute node completes the calculation of the execution task, releases the corresponding compute resource, and continues to monitor the task queue, so that the compute node continues to monitor the task queue. Computational resources can be continuously reused, the user code execution process does not always have to occupy the compute node, asynchronous communication of user code execution is realized, and the simultaneous execution capacity of the system is improved. The compute node always occupies the compute resource of the compute node because it acquires the execution task, calculates it, acquires the calculation result, releases the corresponding compute resource, and continues to acquire new execution tasks. Instead, it is possible to improve the resource utilization rate by realizing the reuse of the computational resources of the same computational node.

According to the above method, the programming platform includes a service node, a task queue and a compute node, the service node and the compute node are installed separately, and the service node obtains a user code for representing a user terminal. The user code is registered in the task queue as an execution task, the compute node monitors the task queue and gets the execution task, the compute node calculates the execution task and gets the calculation result, and the service node The calculation result is acquired from the calculation node, and the calculation result is fed back to the user terminal. As a result, the service node realizes the connection with the user terminal, and the calculation node realizes the execution of the user code in order to realize the calculation of the user code. In addition, since the service node and the calculation node are installed separately during the execution of the user code, the connection of the user terminal and the calculation of the user code are completed by the service node and the calculation node, respectively, and asynchronous communication of the execution of the user code is performed. Realize and improve the simultaneous execution capacity of the system.

The present application further provides a service node capable of executing a method of executing a user code of a programming platform. Referring to FIG. 2, FIG. 2 is a schematic diagram of another implementation process of a method of executing a user code of a programming platform according to an embodiment of the present application. Specifically, the method of the embodiment of the present application includes the following steps.

In step S201, the user code for representing the user terminal is acquired.

In the embodiment of the present application, the service node that executes the method of executing the user code of the programming platform is the service node in any embodiment of the method of executing the user code of the programming platform described above. The programming platform includes service nodes, task queues and compute nodes.

The service node can receive the user code of any of the plurality of user terminals, can receive the user codes of the plurality of user terminals at the same time, and can support the simultaneous connection of the plurality of user terminals. The method of receiving the user code by the service node includes, but is not limited to, a method of receiving by the websocket communication technology and the HTTP communication technology, and is not particularly limited here. The source of user code received by the service node can be diversified. For example, the code editing window of the user terminal itself acquires the code edited by the user to form the user code, or the user terminal receives the user code transmitted by the code editing device connected to the user terminal. do.

In the embodiment of the present application, the service node acquires the user code assigned via the reverse proxy, and the user terminal does not need to establish a one-to-one correspondence with the service node. Execute the user code assignment of the terminal.

In step S202, the user code is registered in the task queue as an execution task so that the calculation node acquires the execution task from the task queue and calculates it.

By registering the user code as an execution task in the task queue, the service node can evenly allocate the execution tasks in the task queue, and the queuing mechanism can improve the simultaneous response capability of the system. The service node acquires the user code of the user terminal, maintains the session connection with the user terminal, and realizes the connection with the user terminal. In the case of user code, after registering the user code as an execution task in the task queue, the calculation node acquires the execution task from the task queue and calculates it, so that the connection of the user terminal and the calculation of the user code are performed by the service node. And complete by the compute node, it realizes asynchronous communication of user code execution and improves the simultaneous execution capacity of the system.

In the embodiment of the present application, the task queue includes a first task queue and a second task queue, and the calculation node includes a first calculation node and a second calculation node. When the service node registers the user code as an execution task in the task queue so that the calculation node can acquire the execution task from the task queue and calculate it, the first task uses the user code as the execution task according to the calculation characteristics of the user code. By registering in the queue or the second task queue, the first compute node can acquire the execution task from the first task queue and calculate it, or the second compute node acquires the execution task from the second task queue. To be able to calculate.

For the remaining description of steps S201 and S202, the above steps S101 to S103 can be referred to and will not be repeated here.

In step S203, the calculation result of the calculation node is acquired, and the calculation result is fed back to the user terminal.

After the calculation node acquires the calculation result, the service node can acquire the calculation result from the calculation node and feed back the calculation result to the user terminal. In an embodiment of the present application, the programming platform further includes a message queue, which is used to temporarily store the calculation result acquired by the compute node computing the execution task. When the service node acquires the calculation result from the calculation node and feeds back the calculation result to the user terminal, the service node monitors the message queue to acquire the calculation result and feeds back the calculation result to the user terminal. Here, the calculation result acquired by the service node is the calculation result registered in the message queue by the calculation node.

In the embodiment of the present application, the service node establishes a session connection with the user terminal after acquiring the user code for representing the user terminal, and the service node establishes a session connection with the user terminal until the calculation result is acquired. Maintaining, the service node disconnects the session connection with the corresponding user terminal after acquiring the calculation result of the compute node. As a result, the service node maintains the connection between the service node and the user terminal until the calculation result is acquired, and facilitates feedback of the calculation result to the user terminal.

According to the above method, the service node acquires the user code for representing the user terminal, and the compute node puts the user code into the task queue as the execution task so as to acquire the execution task from the task queue and calculate. Execution of the user code is realized by registering, acquiring the calculation result of the calculation node, and feeding back the calculation result to the user terminal. The service node is configured to connect to the user terminal and register the user code issued by the user terminal in the task queue as an execution task, so that the compute node independent of the service node can execute the task from the task queue. After acquiring the calculation result by acquiring and calculating, the service node acquires the calculation result of the calculation node and feeds back the calculation result to the user terminal to realize the execution of the user code.

The present application further provides a compute node capable of executing a method of executing a user code of a programming platform. Referring to FIG. 3, FIG. 3 is a schematic diagram of yet another implementation process of the method of executing the user code of the programming platform according to the embodiment of the present application. Specifically, the method of the embodiment of the present application includes the following steps.

In step S301, the task queue is monitored and the execution task is acquired.

In the embodiments of the present application, the compute node that executes the method of executing the user code of the programming platform is the compute node in any embodiment of the method of executing the user code of the above platform. The task queue contains the execution task, and the execution task corresponds to the user code.

The compute node monitors the task queue including the execution task, and acquires the execution task corresponding to the user code on a one-to-one basis from the task queue.

The compute node includes a first compute node and a second compute node, the first compute node and the second compute node are located on the CPU server and the GPU server, respectively, so that the first compute node is in the task queue. , The execution task that depends on the calculation resource and the memory resource of the CPU server is monitored, and the second calculation node monitors the execution task that depends on the calculation resource and the memory resource of the GPU server in the task queue. Specifically, the task queue may include a first task queue and a second task queue, and the first compute node and the second compute node may include the first task queue and the second task in order to acquire an execution task, respectively. Monitor the queue.

That is, the user code corresponds to the task queue, and when the calculation node according to the embodiment of the present application is the first calculation node, the execution task depending on the calculation resource and the memory resource of the CPU server is acquired from the first task queue. , When the compute node is the second compute node, the execution task that depends on the compute resource and the memory resource of the GPU server is acquired from the second task queue.

In step S302, the execution task is calculated and the calculation result is acquired.

The compute node uses the compute and memory resources of the server to which it belongs to compute the execution task and get the computation result. After completing the calculation of the execution task, the compute node releases the corresponding compute resource and continues to monitor the task queue. That is, the compute node maximizes compute and memory resources because it releases resources after it completes the calculation of the current execution task and continues to monitor the task queue to get new execution tasks. Can be reused.

According to the above method, the task queue is monitored and the execution task is acquired, the task queue includes the execution task, the execution task corresponds to the user code, the execution task is calculated, and the calculation result is acquired. , Achieves orderly execution task acquisition by compute nodes. Since the task queue contains the execution task and the execution task corresponds to the user code, the compute node monitors the task queue including the execution task, acquires the execution task corresponding to the user code, and calculates the execution task. By acquiring the calculation result, the execution task can be acquired and the calculation can be realized.

The present application further provides a programming platform, and as shown in FIG. 4, FIG. 4 is a schematic structural diagram of the programming platform according to an embodiment of the present application. Specifically, the programming platform 40 according to the embodiment of the present application includes a service node 41, a task queue 42, and a calculation node 43. The service node 41 is configured to acquire a user code for representing a user terminal and register the user code as an execution task in the task queue 42, and the calculation node 43 monitors the task queue 42 and acquires an execution task. The calculation node 43 is further configured to calculate the execution task and acquire the calculation result, and the service node 41 further acquires the calculation result from the calculation node 43 and obtains the calculation result from the user terminal. It is configured to feed back to.

In the embodiment of the present application, the number of the calculation nodes 43 is at least two, and when the calculation nodes 43 are configured to monitor the task queue 42 and acquire the execution task, the at least two calculation nodes 43 are in the task queue. The task queue 42 is configured to monitor the 42 and request the task queue 42 to acquire the execution task, and the task queue 42 is configured to allocate one execution task to one compute node 43.

In the embodiment of the present application, the task queue 42 includes a first task queue and a second task queue, at least two calculation nodes 43 include a first calculation node and a second calculation node, and a service node 41 holds a user code. When configured to be registered in the task queue 42 as an execution task, the service node 41 is further configured to register the user code in the first task queue or the second task queue as an execution task according to the calculation characteristics of the user code. The compute node 43 is configured to monitor the task queue 42, specifically, the first compute node monitors the first task queue and the second compute node monitors the second task queue.

In the embodiment of the present application, the number of service nodes 41 is at least two, and when the service nodes 41 are configured to acquire a user code for representing a user terminal, the at least two service nodes 41 have a reverse proxy. It is configured to get the user code assigned through.

In the embodiment of the present application, the calculation node 43 is further configured to release the corresponding calculation resource and continue to monitor the task queue 42 after completing the calculation of the task.

In the embodiment of the present application, the programming platform 40 further includes a message queue 44, and when the service node 41 is configured to acquire the calculation result from the calculation node 43 and feed back the calculation result to the user terminal, the calculation node. 43 is further configured to register the calculation result in the message queue 44, and the service node 41 is further configured to monitor the message queue 42 to acquire the calculation result and feed back the calculation result to the user terminal. ..

In the embodiment of the present application, the service node 41 is further configured to maintain a session connection with the user terminal until the calculation result is acquired.

The service node 41 of the programming platform 40 of FIG. 4 is further configured to execute the method of executing the user code of the programming platform. Specifically, as shown in FIG. 5, FIG. 5 is a schematic structural diagram of an embodiment of the service node 41 of the programming platform according to the present application. The service node 41 includes a receiving unit 411, a registration unit 412, and an acquisition unit 413. Here, the receiving unit 411 is configured to acquire a user code for representing the user terminal, and the registration unit 412 executes the user code so that the compute node can acquire the execution task from the task queue and calculate it. It is configured to be registered in the task queue as a task, and the acquisition unit 413 is configured to acquire the calculation result of the calculation node and feed back the calculation result to the user terminal.

In the embodiment of the present application, when the registration unit 412 is configured to register the user code as an execution task in the task queue so that the calculation node can acquire the execution task from the task queue and calculate the execution task, the registration unit 412 is configured. Further, by registering the user code as an execution task in the first task queue or the second task queue according to the calculation characteristics of the user code, the first calculation node can acquire the execution task from the first task queue and calculate it. Or it is configured to allow the second compute node to retrieve the executed task from the second task queue and compute it.

In the embodiment of the present application, the receiving unit 411 is configured to acquire the user code assigned via the reverse proxy when acquiring the user code for representing the user terminal.

In the embodiment of the present application, the acquisition unit 413 is configured to maintain the session connection between the service node 41 and the user terminal until the calculation result is acquired.

The compute node 43 of the programming platform 40 of FIG. 4 is further configured to execute the method of executing the user code of the programming platform. Specifically, as shown in FIG. 6, FIG. 6 is a schematic structural diagram of an embodiment of the compute node 43 of the programming platform according to the present application. The calculation node 43 includes a monitoring unit 431 and a calculation unit 432, and the monitoring unit 431 is configured to monitor a task queue and acquire an execution task, wherein the task queue includes an execution task and the execution task is. Corresponding to the user code, the calculation unit 432 is configured to calculate the execution task and acquire the calculation result.

In the embodiment of the present application, the calculation unit 432 is configured to release the corresponding calculation resource and continue to monitor the task queue after completing the calculation of the execution task.

To further illustrate the programming platform of the present application, with reference to FIG. 7, FIG. 7 is another schematic structural diagram of the programming platform according to the embodiment of the present application.

The programming platform 70 according to the embodiment of the present application includes a service node 71, a task queue 72, a calculation node 73, and a message queue 74, and the task queue 72 includes a first task queue 721 and a second task queue 722, and is a calculation node. 73 includes a first computing node 731 and a second computing node 732, the first computing node 731 is located on the CPU server 701, and the second computing node 732 is located on the GPU server 702.

In certain applications, the service node 71 may receive the user code of any of the plurality of user terminals and may simultaneously receive the user code of the plurality of user terminals, thereby representing the user terminal. It is possible to acquire the user code of. The service node 71 is connected to the user terminal via the websocket, that is, the service node 71 acquires the user code of the user terminal by the websocket communication method. When the user code is registered in the task queue 72 as an execution task, if it is determined that the user code belongs to the first task queue 721 and uses the code execution resource of the CPU server 701 according to the calculation characteristics of the user code, the user code is executed. Registered in the first task queue 721 as a task, the first calculation node 731 monitors the first task queue 721, acquires an execution task, and calculates, thereby acquiring a calculation result. Alternatively, if it is determined that the user code belongs to the second task queue 722 and uses the code execution resource of the GPU server 702 according to the calculation characteristics of the user code, the user code is registered in the second task queue 722 as an execution task, and the second task queue 722 is registered. 2 The calculation node 732 monitors the second task queue 722, acquires the execution task, and calculates, thereby acquiring the calculation result. Both the first calculation node 731 and the second calculation node 732 register the calculation result in the message queue 74, and the service node 71 monitors the message queue 74 to acquire the calculation result, and the user terminal corresponding to the calculation result. Give feedback to. The description of the service node 71, the task queue 72, the calculation node 73, and the message queue 74 in the embodiment of the present application can refer to the above-mentioned embodiment of the programming platform, and will not be repeated here.

According to the above method, the service node registers the received user code as an execution task in different task queues, and then the compute node of the different server monitors the different task queues and acquires the corresponding execution task. And thereby, the execution task is calculated using different calculation resources and memory resources, and the calculation result is obtained. The calculation node registers the calculation result in the message queue, and finally, the service node acquires the calculation result of the calculation node from the message queue and feeds back the calculation result to the user terminal. Since the service node and the calculation node are installed separately in the entire user code execution process, the connection of the user terminal and the calculation of the user code are completed by the service node and the calculation node, respectively, and the calculation resource of the calculation node continues. Recycled, different compute nodes correspond to different message queues, thereby achieving asynchronous communication of user code execution by acquiring and computing user codes that depend on different compute and memory resources. And improve the concurrency of the system.

In the embodiments of the present application, the programming platform can be an online programming education platform or an artificial intelligence platform. For example, a programming platform is an online programming education platform for schools and training centers, and a user terminal is a student terminal that accesses an online programming education platform and realizes execution of user code. The online programming education platform comprises service nodes, task queues and compute nodes, where the task queue is a redis list. The student enters the user code through the programming interface of the student terminal, and the service node can receive the user code of the student terminal and can receive the user code of multiple student terminals at the same time. , Achieves reception of user codes issued by students on an online programming education platform. The service node registers the user code as an execution task in the redis list of the task queue. The compute node monitors the redis list, acquires the execution task, calculates the execution task, and acquires the calculation result. The service node acquires the calculation result from the calculation node and feeds back the calculation result to the student terminal.

In the embodiment of the present application, the programming platform is an online programming education platform, and the user terminal is a student terminal accessing the online programming education platform. The online programming education platform includes a service node, a task queue, a compute node and a message queue, where the task queue is a redis list and includes a first task queue and a second task queue, where the compute node is the first. The message queue is RabbitMQ, including a compute node and a second compute node. When the service node of the online programming education platform determines that the user code belongs to the first task queue and uses the code execution resource of the CPU server according to the calculation characteristics of the user code, the user code is set as the execution task in the first task queue. After registering, the first calculation node monitors the first task queue, acquires the execution task, and calculates, thereby acquiring the calculation result. Alternatively, when the service node determines that the user code belongs to the second task queue and uses the code execution resource of the GPU server according to the calculation characteristics of the user code, the service node registers the user code as an execution task in the second task queue. The second calculation node monitors the second task queue, acquires the execution task, and calculates, thereby acquiring the calculation result. Both the first calculation node and the second calculation node register the calculation result in the message queue (RabbitMQ), and the service node monitors the RabbitMQ, acquires the calculation result, and feeds back the calculation result to the corresponding student terminal. ..

With the above method, the online programming education platform for schools and training centers will allow more students to perform online programming learning on the online programming education platform at the same time, maximizing computational resources and saving costs. be able to.

Referring to FIG. 8, FIG. 8 is a schematic diagram of a framework for an electronic device according to the present application. Specifically, the electronic device 800 of the embodiment of the present application includes a memory 810 and a processor 820 that are coupled to each other. Here, the memory 810 is configured to store program instructions and data necessary for processing by the processor 820.

The processor 820 controls the memory 810 and the processor 820 itself so as to realize the steps of any embodiment of the method of executing the user code of the programming platform described above. The processor 820 is also referred to as a central processing unit (CPU). The processor 820 can be an integrated circuit chip with a signal processing function. The above-mentioned processors include general-purpose processors, digital signal processors (DSPs), integrated circuits for specific applications (ASICs), field programmable gate arrays (FPGAs), and field programmable gate arrays (FPGAs: Field Programmable Logic). It may be a device, a discrete gate or transistor logic device, a discrete hardware component, and the like. The general-purpose processor may be a microprocessor, an arbitrary conventional processor, or the like. Further, the processor 820 can be jointly realized by a plurality of integrated circuit chips.

Referring to FIG. 9, FIG. 9 is a schematic diagram of the framework of the storage device according to the present application. The storage device 900 according to the present application stores a processor-executable program instruction 901, and the program instruction 901 is used to realize the steps of the embodiment of the method of executing the user code of any of the above programming platforms. The program.

Specifically, the storage device 900 can store a U disk, a mobile hard disk, a read-only memory (ROM: Read-Only Memory), a random access memory (RAM: Random Access Memory), and a magnetic disk capable of storing a program instruction 901. Alternatively, it may be a medium such as an optical disk (volatile storage medium or non-volatile storage medium), or it may be a server in which the program instruction 901 is stored. The server can transmit the stored program instruction 901 to another device and execute it, or can independently execute the stored program instruction 901.

It should be understood that in some of the embodiments provided herein, the disclosed methods and devices can be implemented in other ways. For example, the embodiment of the above apparatus is merely exemplary, for example, the division of a module or unit is merely a division of a logical function, and in actual realization, other division methods may exist, for example, a plurality. Units or components can be combined, integrated into another system, or some features can be ignored or not implemented. Further, the interconnect or direct coupling or communication connection displayed or discussed can be an indirect coupling or communication connection via some interface, device or unit of electrical, mechanical or other form.

The unit described as a separating member may or may not be physically separated, and the member labeled as a unit may or may not be a physical unit and is located in one place. In some cases, it may be distributed over multiple network units. Part or all of the above units may be selected as needed in practice to achieve the objectives of the technical proposal of this embodiment.

Further, each functional unit in each embodiment of the present application may be integrated into one processing unit, each unit may be used separately as one unit, or two or more units may be used as one unit. May be integrated into. The integrated unit may be implemented in the form of hardware or in the form of a software functional unit.

When the integrated unit is realized in the form of a software functional unit and sold or used as a stand-alone product, it can be stored on one computer-readable storage medium. Based on this understanding, an essential part of the technical solution of the present application, that is, a part that contributes to the prior art, or all or part of the technical solution, is embodied in the form of a software product. The computer software product can be stored in one storage medium and stored in a computer device (which may be a personal computer, server, network device, etc.) or a processor (processor), according to the method of each embodiment of the present application. Includes several instructions to perform all or part of the steps in. The above storage media can store program codes such as U disks, mobile hard disks, read-only memory (ROM: Read-Only Memory), random access memory (RAM: Random Access Memory), magnetic disks, or optical disks. Includes various media.

This application discloses a method of executing a user code of a programming platform and a platform, a node, a device, and a medium. Here, the programming platform includes a service node, a task queue, and a calculation node, and the method of executing the user code of the programming platform is that the service node acquires the user code for representing the user terminal and executes the user code. Registering in the task queue as a task, the compute node monitors the task queue and acquires the execution task, the compute node calculates the execution task and acquires the calculation result, and the service node , Acquiring the calculation result from the calculation node and feeding back the calculation result to the user terminal.

Claims (28)

How to execute user code on a programming platform with service nodes, task queues, and compute nodes.
The service node acquires a user code for representing a user terminal and registers the user code as an execution task in the task queue.
When the compute node monitors the task queue and acquires the execution task,
When the calculation node calculates the execution task and obtains the calculation result,
A method of executing a user code of the programming platform, comprising the service node acquiring the calculation result from the calculation node and feeding back the calculation result to the user terminal. The number of the calculation nodes is at least two, and the calculation nodes monitor the task queue and acquire the execution task.
At least two of the compute nodes monitor the task queue and request the task queue to get the execution task.
The task queue comprises allocating one said execution task to one said compute node.
The method of executing the user code of the programming platform according to claim 1. The task queue includes a first task queue and a second task queue, and at least two of the compute nodes include a first compute node and a second compute node.
Registering the user code in the task queue as an execution task is not possible.
Including registering the user code in the first task queue or the second task queue as an execution task according to the calculation feature of the user code.
It is not possible for the compute node to monitor the task queue.
The first compute node monitors the first task queue, and the second compute node monitors the second task queue.
The method of executing the user code of the programming platform according to claim 1. The number of the service nodes is at least two, and it is possible for the service nodes to acquire a user code for representing a user terminal.
At least two said service nodes include getting the said user code assigned via a reverse proxy.
The method of executing the user code of the programming platform according to claim 1 or 2. After completing the calculation of the execution task, the calculation node releases the corresponding calculation resource and continues to monitor the task queue.
The method for executing a user code of a programming platform according to any one of claims 1 to 4. The programming platform further includes a message queue so that the service node can acquire the calculation result from the calculation node and feed the calculation result back to the user terminal.
When the calculation node registers the calculation result in the message queue,
The service node monitors the message queue, acquires the calculation result, and feeds back the calculation result to the user terminal.
The method for executing a user code of a programming platform according to any one of claims 1 to 4. The service node maintains a session connection with the user terminal until the calculation result is acquired.
The method of executing the user code of the programming platform according to claim 6. How to execute user code on a programming platform
Obtaining a user code to represent a user terminal and
Registering the user code as the execution task in the task queue so that the calculation node can acquire the execution task from the task queue and calculate it.
A method of executing a user code of the programming platform, comprising acquiring a calculation result of the calculation node and feeding back the calculation result to the user terminal. Registering the user code as the execution task in the task queue so that the compute node can acquire the execution task from the task queue and calculate it is not possible.
By registering the user code as an execution task in the first task queue or the second task queue according to the calculation feature of the user code, the first calculation node can acquire the execution task from the first task queue and calculate. It also includes allowing the second compute node to obtain and compute the execution task from the second task queue.
The method of executing the user code of the programming platform according to claim 8. Obtaining a user code to represent the user terminal is
Including retrieving the user code assigned via a reverse proxy,
The method of executing the user code of the programming platform according to claim 8 or 9. The method of executing the user code of the programming platform includes maintaining a session connection with the user terminal until the calculation result is acquired.
The method for executing a user code of a programming platform according to any one of claims 8 to 10. How to execute user code on a programming platform
By monitoring the task queue and acquiring the execution task, the task queue includes the execution task, and the execution task corresponds to the user code.
A method of executing a user code of the programming platform, including calculating the execution task and obtaining the calculation result. The method of executing the user code of the programming platform includes releasing the corresponding computational resource and continuing to monitor the task queue after completing the calculation of the execution task.
The method of executing the user code of the programming platform according to claim 12. It ’s a programming platform,
Equipped with service node, task queue and compute node
The service node is configured to acquire a user code for representing a user terminal and register the user code as an execution task in the task queue.
The compute node is configured to monitor the task queue and acquire the execution task.
The calculation node is further configured to calculate the execution task and obtain the calculation result.
The programming platform is configured such that the service node further acquires the calculation result from the calculation node and feeds back the calculation result to the user terminal. If the number of compute nodes is at least two and the compute nodes are configured to monitor the task queue and acquire the execution task, then at least two compute nodes have the task queue. The task queue is configured to monitor and request the task queue to acquire the execution task, and the task queue is configured to assign one execution task to one compute node.
The programming platform according to claim 14. The task queue includes a first task queue and a second task queue, and at least two of the compute nodes include a first compute node and a second compute node.
When the service node is configured to register the user code as an execution task in the task queue, specifically, the service node performs the first task with the user code as an execution task according to the calculation characteristics of the user code. When configured to register in a queue or a second task queue, the compute node is configured to monitor the task queue, specifically, the first compute node is configured to monitor the first task queue. The second compute node is configured to monitor the second task queue.
The programming platform according to claim 15. The number of the service nodes is at least two, and if the service nodes are configured to obtain a user code to represent a user terminal, the at least two service nodes are assigned via a reverse proxy. Configured to retrieve the user code,
The programming platform according to claim 14. The compute node is configured to release the corresponding compute resource and continue to monitor the task queue after completing the computation of the execution task.
The programming platform according to any one of claims 14 to 17. If the programming platform further includes a message queue and the service node is configured to acquire the calculation result from the calculation node and feed the calculation result back to the user terminal, the calculation node is said to be said. The calculation result is configured to be registered in the message queue, and the service node is configured to monitor the message queue, acquire the calculation result, and feed back the calculation result to the user terminal.
The programming platform according to any one of claims 14 to 18. The service node is further configured to maintain a session connection with the user terminal until the calculation result is acquired.
The programming platform of claim 19. A service node
The receiving unit includes a receiving unit, a registration unit, and an acquisition unit, the receiving unit is configured to acquire a user code for representing a user terminal, and the registration unit is calculated by acquiring an execution task from a task queue by a calculation node. The user code is configured to be registered in the task queue as the execution task so that the acquisition unit acquires the calculation result of the calculation node and feeds back the calculation result to the user terminal. The service node to be configured. The registration unit is configured to register the user code as the execution task in the task queue so that the compute node can acquire the execution task from the task queue and calculate it, and the registration unit is further configured with the user code. By registering the user code as an execution task in the first task queue or the second task queue according to the calculation feature of the above, the first calculation node can acquire the execution task from the first task queue and calculate it. Or, it is configured to allow the second compute node to acquire and compute the execution task from the second task queue.
The service node according to claim 21. The receiving unit is configured to acquire a user code for representing a user terminal, and the receiving unit is further configured to acquire the user code assigned via a reverse proxy.
The service node according to claim 21 or 22. The service node is configured to maintain a session connection with the user terminal until the acquisition unit acquires the calculation result.
The service node according to any one of claims 21 to 23. It ’s a compute node,
The monitoring unit includes a monitoring unit and a calculation unit, and the monitoring unit is configured to monitor a task queue and acquire an execution task, the task queue includes the execution task, and the execution task corresponds to the user code. , The calculation unit is configured to calculate the execution task and obtain the calculation result. The calculation unit is further configured to release the corresponding calculation resource and continue to monitor the task queue after completing the calculation of the execution task.
25. The compute node according to claim 25. It ’s an electronic device,
With interconnected memory and processor,
The method according to any one of claims 1 to 7 and / or any one of claims 8 to 11 by executing the program instruction stored in the memory. And / or the electronic device configured to implement the method of claim 12 or 13. A computer-readable storage medium in which a computer program is stored, wherein the method according to any one of claims 1 to 7 and / or claims 8 to 11 when the computer program is executed. The computer-readable storage medium according to any one of the methods and / or the method according to claim 12 or 13.

Images