TWI786527B - User code operation method of programming platform, electronic equipment and computer-readable storage medium - Google Patents

Abstract

The application discloses a user code operation method of a programming platform, electronic equipment and computer-readable storage medium. The programming platform includes a service node, a task queue and a computing node; the method includes: the service node obtains the user code used to represent the user terminal, and places the user code in the task queue as a running task; the computing node monitors the task queue to obtain the running task; the computing node calculates the running task and gets the calculation result; the service node obtains the calculation result from the computing node and feeds back the calculation result to the user terminal.

Description

User code running method of programming platform, electronic device and computer-readable storage medium

The present invention relates to the technical field of programming, in particular to a user code running method of a programming platform, electronic equipment and a computer-readable storage medium.

With the rapid development of artificial intelligence, various systems that rely on code operation have also emerged. Not only is the code more and more diverse, but there are also higher and higher requirements for the functions that the system can provide.

In the face of increasingly complex codes, in the current programming platform, code execution environments such as the Kernel (execution environment) often need to maintain the connection relationship with the user terminal and calculate the code issued by the user terminal, resulting in system Capabilities cannot meet code running requirements.

Based on this, how to improve the concurrency capability of the user code running of the programming platform has become an urgent problem to be solved.

The invention provides a user code running method of a programming platform, electronic equipment and a computer-readable storage medium.

The programming platform of the present invention includes: service nodes, task queues, and computing nodes. The first aspect of the present invention provides a user code running method for a programming platform, including: the service node acquires a user code used to represent a user terminal, and places the user code as a running task in the In the task queue; the computing node monitors the task queue to obtain the running task; the computing node calculates the running task to obtain a calculation result; the service node obtains the computing node from the computing node result, and feed back the calculation result to the user terminal.

Therefore, the service node realizes the connection with the user terminal, and places the user code in the queue, and the calculation node performs the calculation of the user code, and then realizes the operation of the user code. During the operation of the above user code, the service node and the computing node are set separately, so that the connection of the user terminal and the calculation of the user code are completed by the service node and the computing node respectively, realizing the asynchronous communication of the user code running and improving the system concurrent capabilities.

Wherein, the number of the computing nodes is at least two; the computing nodes monitor the task queue to obtain the running tasks, including: at least two of the computing nodes monitor the task queue, and send the The task queue requests to obtain the execution task; the task queue allocates one of the execution tasks to one of the computing nodes.

Therefore, when multiple computing nodes monitor a running task in the task queue, the multiple computing nodes obtain the running task by requesting the task queue, and the task queue assigns the running task to a computing node, through the task Queues can complete the reasonable distribution of running tasks.

Wherein, the task queue includes a first task queue and a second task queue, and at least two of the computing nodes include the first computing node and the second computing node; the placing the user code as a running task In the task queue, including: according to the calculation characteristics of the user code, placing the user code as a running task in the first task queue or the second task queue; the computing node monitors the task The queue includes: the first computing node monitors the first task queue, and the second computing node monitors the second task queue.

Therefore, the service node can distinguish the user code based on the computing characteristics of the user code, and place them in the first task queue or the second task queue respectively, so that different computing nodes monitor different task queues, so as to target the user code Different operations require different processing of user code.

Wherein, the number of the service nodes is at least two; the service node obtaining the user code used to characterize the user terminal includes: at least two of the service nodes are assigned the user code through a reverse proxy.

Therefore, the present invention can provide at least two service nodes, and the service nodes are assigned user codes through the reverse proxy, so that multiple service nodes can receive the user codes sent by the user terminal, and the concurrent processing capability can be improved.

Wherein, after the computing node finishes computing the running task, it releases the corresponding computing resource and continues to monitor the task queue.

Therefore, after the computing node completes the calculation, it will release resources and continue to monitor the task queue to obtain new running tasks. After the computing node executes the running tasks, it will release resources, so that computing and memory resources can be reused, and hardware can be fully and reasonably used resource.

Wherein, the programming platform further includes a message queue; the service node obtains the calculation result from the computing node to feed back the computing result to the user terminal, including: the computing node sends the The calculation result is placed in the message queue; the service node monitors the message queue to obtain the calculation result, and feeds back the calculation result to the user terminal.

Therefore, after the computing node executes the operation task corresponding to any user code, it will place the calculation results in the message queue uniformly. The service node monitors the message queue to obtain the calculation results of the computing nodes, so that the calculation results are also processed. Unified management.

Wherein, the service node maintains a session connection with the user terminal before obtaining the calculation result.

Therefore, before obtaining the calculation result, the service node keeps the session connection with the user terminal, that is, maintains the connection between the service node and the user terminal, so as to feed back the calculation result to the user terminal.

The second aspect of the present invention provides a user code running method of a programming platform, the method includes acquiring a user code used to characterize a user terminal; placing the user code as a running task in a task queue, and The computing node obtains and calculates the running task from the task queue; obtains the computing result of the computing node, and feeds back the computing result to the user terminal.

Therefore, the service node is used to connect with the user terminal, and place the user code sent by the user terminal as a running task in the task queue, so that the computing node independent of the service node obtains and calculates the running task from the task queue After obtaining the calculation result, the service node obtains the calculation result of the calculation node, and feeds back the calculation result to the user terminal to realize the operation of the user code.

Wherein, the placing the user code as a running task in a task queue so that the computing node obtains and calculates the running task from the task queue includes: according to the calculation characteristics of the user code , placing the user code as a running task in the first task queue or the second task queue, so that the first computing node obtains and calculates the running task from the first task queue, or by The second calculation node acquires and calculates the running task from the second task queue.

Therefore, the service node can distinguish the user code based on the computing characteristics of the user code, and place them in the first task queue or the second task queue respectively, so that different computing nodes monitor different task queues, so as to target the user code Different operations require different processing of user code.

Wherein, said obtaining the user code used to characterize the user terminal includes: being assigned the user code through a reverse proxy.

Therefore, the service node is assigned the user code through the reverse proxy, so that the service node is reasonably assigned to receive the user code sent by the user terminal.

Wherein, the method includes: before obtaining the calculation result, maintaining a session connection with the user terminal.

Therefore, before obtaining the calculation result, the service node keeps the session connection with the user terminal, that is, maintains the connection between the service node and the user terminal, so as to feed back the calculation result to the user terminal.

The third aspect of the present invention provides a user code running method of a programming platform, the method includes: monitoring the task queue to obtain running tasks; the running tasks are included in the task queue, and the running tasks correspond to The user code; calculating the running task to obtain a calculation result.

Therefore, the task queue includes the running task, and the running task corresponds to the user code, so the computing node monitors the task queue including the running task, thereby obtaining the running task corresponding to the user code, and then calculates the running task to obtain the calculation result, and realizes Acquisition and calculation of running tasks.

Wherein, the user code running method of the programming platform further includes: after completing the calculation of the running task, releasing the corresponding computing resources and continuing to monitor the task queue.

Therefore, after the computing node completes the calculation, it releases resources, and continues to monitor the task queue to obtain new running tasks, so that user code can be executed in different computing nodes, and the computing node releases resources after executing the running tasks, making computing And memory resources are reused, and hardware resources are fully and reasonably used.

The fourth aspect of the present invention provides a programming platform, which includes: a service node, a task queue, and a computing node; the service node is configured to obtain a user code used to represent a user terminal, and the User code is placed in the task queue as a running task; the computing node is configured to monitor the task queue to obtain the running task; the computing node is also configured to compute the running task to obtain the computed Result; the service node is further configured to obtain the calculation result from the calculation node, so as to feed back the calculation result to the user terminal.

Wherein, the number of the computing nodes is at least two; the computing nodes are configured to monitor the task queue, so as to obtain the running tasks, at least two of the computing nodes are configured to monitor the task queue, requesting the execution task from the task queue; the task queue is configured to assign one of the execution tasks to one of the computing nodes.

Wherein, the task queue includes a first task queue and a second task queue, and at least two of the computing nodes include a first computing node and a second computing node; the service node is used to use the user code When placing the user code as a running task in the task queue, specifically, the service node is configured to place the user code as a running task in the first task queue or the second task according to the calculation characteristics of the user code In the queue; the computing node is used to monitor the task queue, specifically, the first computing node is used to monitor the first task queue, and the second computing node is used to monitor the second task queue.

Wherein, the number of the service nodes is at least two; when the service nodes are configured to obtain the user code used to characterize the user terminal, at least two of the service nodes are configured to be assigned the usage code through the reverse proxy or code.

Wherein, the computing node is configured to release corresponding computing resources and continue to monitor the task queue after completing the computing of the running task.

Wherein, the programming platform further includes a message queue; the service node is configured to obtain the calculation result from the computing node, so that when feeding the computing result back to the user terminal, the computing node is configured To place the calculation result in the message queue; the service node is configured to monitor the message queue to obtain the calculation result, and feed back the calculation result to the user terminal.

Wherein, the service node is further configured to maintain a session connection with the user terminal before obtaining the calculation result.

The fifth aspect of the present invention provides a service node, including a receiving unit, a placing unit, and an acquiring unit, the receiving unit is configured to acquire a user code used to represent a user terminal; the placing unit is configured to place the user The code is placed in the task queue as a running task, so that the computing node acquires and calculates the running task from the task queue; the obtaining unit is configured to obtain the calculation result of the computing node, and the computing node The result is fed back to the user terminal.

Wherein, the placing unit is configured to place the user code as a running task in the task queue, so that when the computing node obtains and calculates the running task from the task queue, it is also configured to The calculation feature of the user code, the user code is placed as a running task in the first task queue or the second task queue, so that the first computing node can obtain and calculate all The running task, or the second computing node obtains and calculates the running task from the second task queue.

Wherein, when the receiving unit is configured to obtain the user code used to characterize the user terminal, it is also configured to be assigned the user code through a reverse proxy.

Wherein, before the obtaining unit obtains the calculation result, the service node is configured to maintain a session connection with the user terminal.

The sixth aspect of the present invention provides a computing node, including a monitoring unit and a computing unit, and the monitoring unit is configured to monitor a task queue to acquire running tasks; wherein the running task is included in the task queue, and the running task The task corresponds to the user code; the calculation unit is configured to calculate the running task and obtain a calculation result.

Wherein, after the computing unit completes the computing of the running task, it is further configured to release corresponding computing resources and continue to monitor the task queue.

The seventh aspect of the present invention provides an electronic device, including a memory and a processor coupled to each other; the processor is used to execute the program instructions stored in the memory, so as to realize the user of the programming platform of the first aspect above A code running method; and/or, to realize the user code running method of the programming platform of the second aspect above; and/or, to realize the user code running method of the programming platform of the third aspect above.

Therefore, the service node is used to realize the connection with the user terminal, and puts the user code in the queue, and the calculation node is used to calculate the user code, and then realize the operation of the user code. During the operation of the above user code, the service node and the computing node are set separately, so that the connection of the user terminal and the calculation of the user code are completed by the service node and the computing node respectively, realizing the asynchronous communication of the user code running and improving the system concurrent capabilities.

The eighth aspect of the present invention provides a computer-readable storage medium, on which are stored program instructions that can be executed by a processor, and the program instructions are used to implement the user code running method of the programming platform of the first aspect above; and/or , realizing the user code running method of the programming platform of the second aspect above; and/or, realizing the user code running method of the programming platform of the third aspect above.

Therefore, during the operation of the above user code, the service node is used to realize the connection with the user terminal, and the computing node is used to realize the calculation of the user code, realize the asynchronous communication of the user code operation, and improve the concurrency capability of the system .

Various exemplary embodiments, features, and aspects of embodiments of the present invention will be described in detail below with reference to the accompanying drawings. The same reference numbers in the figures indicate functionally identical or similar elements. While various aspects of the embodiments are shown in drawings, the drawings are not necessarily drawn to scale unless specifically indicated.

The solutions of the embodiments of the present invention will be described in detail below in conjunction with the accompanying drawings.

The following will clearly and completely describe the technical solutions in the embodiments of the present invention with reference to the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are only some, not all, embodiments of the present invention. Based on the embodiments of the present invention, all other embodiments obtained by persons of ordinary skill in the art without making creative efforts belong to the protection scope of the present invention. The terms "first" and "second" herein are only used for descriptive purposes, and cannot be understood as indicating or implying relative importance or implicitly specifying the quantity of indicated technical features.

In some embodiments, with the popularization of artificial intelligence, machine learning and artificial intelligence programming education have gradually become an important part of programming education. Different from conventional introductory programming education, the artificial intelligence code executed by students in artificial intelligence programming education often needs to achieve a large amount of calculations, and the corresponding resource overhead is also relatively large, such as (central processing unit, central processing unit) CPU/GPU ( Graphics Processing Unit, graphics processor) occupancy rate, memory space, etc. In the programming education platform of the related technology, an independent Kernel is created for each user and stored in the server memory, so that each user can perform programming experiments in the created independent Kernel. In this way, due to the large resource overhead required by the artificial intelligence code, each Kernel occupies a large amount of CPU/GPU resources and memory space. If each user's Kernel is resident in memory, the overall overhead is huge and the resource utilization rate is low; Moreover, there is a strict one-to-one correspondence between each user and Kernel, so the number of users who can learn online programming at the same time is limited by the number of Kernels that the server can support; due to the runtime of each user's Kernel process The environment is constant, making it impossible to flexibly schedule user codes to be executed on different machines according to the resource occupation of the user code. In the case of multi-machine deployment, it is easy to cause unreasonable resource allocation, which is not conducive to improving the system's concurrency capability. In this way, in the artificial intelligence online programming education, the cost of the server has increased sharply, making it difficult to promote and popularize.

Based on this, the embodiment of the present invention provides a user code running method of a programming platform. By constructing a group of equal service nodes and a group of equal computing nodes, after the user submits the code, the user code is passed through websocket (full-duplex communication) protocol) technology to transmit the user code to any service node. The service node creates a running task and puts it into the task queue and maintains the current session connection. After any computing node obtains the running task from the task queue, it executes the user code and immediately returns the execution result through the task queue To the corresponding service node, the computing node releases the resource immediately. The service node reads the execution result from the task queue and pushes it back to the user terminal in real time through the full-duplex communication protocol, and ends the current session after the push is completed. Among them, the service node supports multiple concurrent connections, and the computing node supports single task execution.

The implementation flow of the method is shown in FIG. 1 . FIG. 1 is a schematic diagram of an implementation flow of a user code running method of a programming platform provided by an embodiment of the present invention. Specifically, the method in the embodiment of the present invention includes the following steps.

Step S101: the service node obtains the user code used to represent the user terminal, and places the user code as a running task in the task queue.

The programming platform of the embodiment of the present invention includes service nodes, task queues and computing nodes.

The service node can obtain the user code of any one of the multiple user terminals, and can simultaneously obtain the user codes of multiple user terminals, so as to support concurrent connections of multiple user terminals. A service node can be implemented by any electronic device with processing capabilities such as a server and a computer. Wherein, the electronic device can also be used to perform other functions, for example, the electronic device can also be used to perform the calculation of the operation task obtained by the computing node, that is, the service node and the computing node can be implemented by the same electronic device or by different electronic devices. The way the service node receives the user code includes but not limited to websocket communication technology, HTTP (Hyper Text Transfer Protocol, hypertext transfer protocol) communication technology, which is not specifically limited here. The source of the user code received by the service node can be diversified. For example, the code editing window that comes with the user terminal obtains the code edited by the user to form a user code, or the user terminal receives the code editing device connected to it. The transmitted user code, etc.

In the embodiment of the present invention, the number of service nodes is at least two. When the service node obtains the user code used to represent the user terminal, at least two service nodes are assigned the user code through the reverse proxy. These service nodes open services to the front-end applications. The full-duplex communication protocol is used for communication between the front-end applications and the service nodes. The service nodes receive the user codes of the user terminals assigned by the reverse proxy server. Among them, the user terminal The user code represents the identification information of the user terminal, for example, indicates the serial number of the user terminal, or the user account of the user terminal. Use the reverse proxy server to realize the user code distribution between the user terminal and at least two service nodes. When the reverse proxy server obtains the user code of the user terminal, it can distribute the user code to at least two service nodes. service nodes, so that each service node is assigned a user code through the reverse proxy. Likewise, the service node can receive user codes of multiple user terminals at the same time, supporting concurrent connections of multiple user terminals.

After the service node receives the user code, it creates a running task for each user code, and places the running task in the task queue, so that the task queue includes all the one-to-one correspondence with the user code released by the service node. Run the task. The queuing queue can be a storage system such as Redis (Remote Dictionary Server, remote dictionary service) list, and message-oriented intermediary software such as RabbitMQ (Message Queue, message queue).

In the embodiment of the present invention, according to the resource dependency requirements of the user code, the execution tasks corresponding to the user code are separated and placed. Specifically, the task queue includes a first task queue and a second task queue, and the running tasks in the first task queue and the second task queue will depend on different code resources when being calculated, for example, the first task The execution tasks in the queue depend on the CPU code execution environment resources, while the execution tasks in the second task queue depend on the GPU code execution environment resources. The allocation of running tasks in the first task queue and the second task queue depends on the calculation characteristic of the user code, that is, the calculation characteristic is used to indicate that the user code belongs to the first task queue or the second task queue . Wherein, the expression form of the calculation feature includes but not limited to a character string identifier with a preset bit length, a binary code, etc. in the user code. Therefore, when the service node places the user code as the running task in the task queue, it places the user code as the running task in the first task queue or the second task queue according to the computing characteristics of the user code.

In the embodiment of the present invention, the task queue may include at least two subtask queues, and the association relationship between the service node and multiple subtask queues may be established in advance, the service node obtains the user code used to represent the user terminal, and Place user codes as running tasks in different subtask queues, or establish associations between multiple service nodes and multiple subtask queues, and some service nodes assign received user codes to establish associations with them A part of the subtask queue, and another part of the service node assigns the received user code to another part of the subtask queue that establishes an association relationship with it, so as to realize the corresponding relationship between the service node and the task queue.

Step S102: The computing node monitors the task queue to obtain running tasks.

The task queue includes a running task, so that the computing node monitors the task queue, and when it detects that the computing node contains a running task that can be executed by the computing node, the running task can be obtained. The way the computing node obtains running tasks from the task queue, including but not limited to, the task queue actively assigns running tasks to computing nodes, or the computing node requests running tasks from the task queue, and the task queue assigns running tasks according to the request to compute nodes.

In the embodiment of the present invention, the number of computing nodes is at least two. When the computing node monitors the task queue to obtain the running task, at least two computing nodes monitor the task queue and request the running task from the task queue; the task queue assigns a running task to a computing node, so that the task queue is completed Reasonable distribution of running tasks. Task Queue The rules for assigning running tasks to computing nodes can be customized. For example, the priority levels of all computing nodes are stored in advance. When the task queue receives requests from multiple computing nodes for the same running task at the same time, the task will be run Allocation to computing nodes with high priority; or assigning running tasks to computing nodes that obtain the fewest running tasks within a preset time, which is not specifically limited here.

In the embodiment of the present invention, when the task queue includes the first task queue and the second task queue, and the computing node includes the first computing node and the second computing node, the monitoring task queue of the computing node is specifically the first computing node The node monitors the first task queue, and the second computing node monitors the second task queue, so that different computing nodes monitor different task queues respectively, which facilitates management and improves the efficiency of obtaining running tasks. Wherein, the first computing node and the second computing node can be respectively located on servers with different configurations, so that they have different computing and storage resources respectively, and can realize computing of different user codes. For the calculation of the user code, the calculation and storage resources on which the user code is calculated can be obtained from the calculation feature, that is, the calculation feature of the user code is used to indicate that the user code belongs to the first task queue or the second The task queue further indicates that the user code is computed by the first computing node or the second computing node on servers of different configurations.

Further, the first computing node is set on the CPU server, and the second computing node is set on the GPU server; the first task queue includes running tasks that depend on CPU code execution environment resources, and the second task queue includes tasks that depend on GPU code Execute the running tasks of the environment resources; thus, the first computing node on the CPU server monitors the first task queue to obtain running tasks, and the second computing node on the GPU server monitors the second task queue to obtain running tasks.

Step S103: The computing node computes and runs the task, and obtains the computing result.

Computing nodes use the computing and memory resources available on the server where they are located to calculate the obtained running tasks to obtain the calculation results. After the computing node completes the calculation of the running task, it releases the corresponding computing resources and continues to monitor the task queue, that is, after the computing node completes the calculation of the current running task, it releases resources and continues to monitor the task queue to obtain new running Tasks enable computing nodes to maximize the reuse of computing and memory resources. Wherein, in the present invention, regardless of whether the computing node can obtain any running task in the task queue, or the first computing node and the second computing node respectively obtain the running tasks in the first task queue and the second task queue, the same computing node can be When the execution of the running task is completed, the resources are released, and new running tasks are continuously obtained, as long as the computing and memory resources of the computing node conform to the running environment resources of the user code. Therefore, the user code can be executed in different computing nodes, so that the computing and memory resources of the computing nodes can be reused, and the hardware resources of the server can be fully and reasonably utilized.

As mentioned above, the service node places the user code as a running task in the first task queue or the second task queue according to the calculation characteristics of the user code; the first computing node and the second computing node respectively start from the first task queue The first computing node and the second computing node on the servers with different configurations use their respective computing and memory resources to compute the running tasks and obtain computing results. Therefore, the task queue distributes the execution tasks to the computing nodes according to the actual needs of the user code, and the computing nodes belong to servers with different configurations, so as to realize the rational utilization of resources. For example, the first task queue is a CPU task queue, and the second task queue is a GPU task queue. The first computing node and the second computing node are respectively located on the CPU server and the GPU server. A task queue acquires and calculates running tasks, and a second computing node acquires and calculates running tasks from the second task queue. Specifically, the calculation feature of a user code indicates that the corresponding user code belongs to the first task queue, and the first computing node obtains the execution task from the first task queue, and uses the calculation and memory resources on the CPU server to calculate Run the task and get the calculation result. The computing nodes on the CPU server can execute regular codes that do not rely on GPU server resources, and the computing nodes on the GPU server can execute codes that use GPU server resources, including but not limited to neural network model training and image processing.

Step S104: the service node obtains the calculation result from the calculation node, and feeds back the calculation result to the user terminal.

After the computing node calculates and runs the task to obtain the calculation result, the service node can obtain the calculation result from the computing node and feed back the calculation result to the user terminal. Ways for service nodes to obtain calculation results from computing nodes include but are not limited to obtaining requests, subscriptions, etc., which are not specifically limited here. The service node obtains the calculation result from the computing node by obtaining a request. The service node monitors the computing node and sends an acquisition request to the computing node to obtain the calculation result, and the corresponding computing node returns the calculation result to the service node according to the acquisition request. When the service node obtains the calculation result from the calculation node by subscription, after the calculation node calculates and runs the task and obtains the calculation result, it directly feeds the calculation result back to the service node.

In the embodiment of the present invention, the programming platform further includes a message queue, and the message queue is used for temporarily storing the calculation results obtained by the computing nodes running tasks. The message queue can be a storage system such as a Redis list, or a message-oriented intermediary software such as RabbitMQ. When the message-oriented service node obtains the calculation result from the calculation node to feed back the calculation result to the user terminal, the calculation node places the calculation result in the message queue; the service node monitors the message queue to obtain the calculation result, and the calculation result Feedback to the user terminal. When the service node obtains the calculation result from the computing node to feed back the calculation result to the user terminal, the service node subscribes to the calculation result of the computing node from the message queue, and feeds back the calculation result to the user terminal through communication technologies such as websocket.

In the embodiment of the present invention, after the service node obtains the user code used to characterize the user terminal, it establishes a session connection with the user terminal; the service node maintains the session connection with the user terminal before obtaining the calculation result; the service node After obtaining the calculation result of the computing node, the session connection with the corresponding user terminal is disconnected. Therefore, before the service node obtains the calculation result, it keeps in touch with the user terminal, so as to conveniently feed back the calculation result to the user terminal. During the operation of the user code, the service node and the computing node are set separately, and the connection of the user terminal and the calculation of the user code are respectively completed by the service node and the computing node. Among them, while the service node maintains a long-term connection with the user terminal, the computing node completes the calculation of the running task, releases the corresponding computing resources and continues to monitor the task queue, so that the computing node continues to reuse computing resources, and the user code It does not need to occupy computing nodes all the time during the running process, realizes asynchronous communication of user code running, and improves the concurrency capability of the system. After the computing node obtains the running tasks and calculates the calculation results, it releases the corresponding computing resources and continues to obtain new running tasks, so that the computing resources of the computing nodes are not occupied all the time, and the computing resources of the same computing node are reused, and then Improve resource utilization.

Through the above method, the programming platform includes service nodes, task queues and computing nodes, so that the service nodes and computing nodes are set separately, and the service nodes obtain the user code used to represent the user terminal, and place the user code as a running task In the task queue; the computing node monitors the task queue to obtain the running task; the computing node calculates the running task and obtains the calculation result; the service node obtains the calculation result from the computing node to feed back the calculation result to the user terminal, so as to serve the node The connection with the user terminal is realized, and the calculation node realizes the calculation of the user code, and then realizes the operation of the user code. In addition, during the operation of the user code, the service node and the computing node are set separately, so that the connection of the user terminal and the calculation of the user code are completed by the service node and the computing node respectively, realizing the asynchronous communication of the user code running and improving The concurrent capability of the system.

The invention also provides a service node, which can also execute the user code running method of the programming platform. Please refer to FIG. 2 . FIG. 2 is a schematic flowchart of another realization of the user code running method of the programming platform provided by the embodiment of the present invention. Specifically, the method in the embodiment of the present invention includes the following steps.

Step S201: Obtain a user code used to represent a user terminal.

The embodiment of the present invention executes the user code running method of the programming platform as the service node in any embodiment of the above-mentioned user code running method of the programming platform. The programming platform includes service nodes, task queues and computing nodes.

The service node can receive the user code of any one of the multiple user terminals, and can simultaneously receive the user codes of multiple user terminals to support concurrent connections of multiple user terminals. The way the service node receives the user code includes but not limited to websocket communication technology and HTTP communication technology, which are not specifically limited here. The source of the user code received by the service node can be diversified. For example, the code editing window of the user terminal obtains the code edited by the user to form a user code, or the user terminal receives the user code transmitted by the code editing device connected to it.

In the embodiment of the present invention, the service node is assigned the user code through the reverse proxy, so that the user terminal and the service node do not need to establish a one-to-one correspondence relationship, and the reverse proxy server performs the user code of the user terminal. distribute.

Step S202: Put the user code as a running task in the task queue, so that the computing node can obtain and calculate the running task from the task queue.

The service node places the user code as a running task in the task queue, so that the running tasks in the task queue are uniformly allocated, and the concurrent response capability of the system can be improved through the queuing mechanism. The service node obtains the user code of the user terminal, and maintains the session connection with the user terminal to realize the connection with the user terminal. For the user code, the user code is placed in the task queue as a running task. After the queue, the calculation node obtains and calculates the running task from the task queue, so that the connection of the user terminal and the calculation of the user code are completed by the service node and the calculation node respectively, so as to realize the asynchronous communication of the user code operation and improve the system concurrent capabilities.

In the embodiment of the present invention, the task queue includes a first task queue and a second task queue, and the computing nodes include the first computing node and the second computing node. The service node puts the user code as a running task in the task queue, so that when the computing node obtains and calculates the running task from the task queue, according to the calculation characteristics of the user code, the user code is placed as the running task in the first In the first task queue or the second task queue, the first computing node acquires and calculates the running tasks from the first task queue, or the second computing node acquires and calculates the running tasks from the second task queue.

For other descriptions of steps S201 and S202, reference may be made to the above steps S101 to S103, which will not be repeated here.

Step S203: Obtain the calculation result of the calculation node, and feed back the calculation result to the user terminal.

After the calculation node obtains the calculation result, the service node can obtain the calculation result from the calculation node, and feed back the calculation result to the user terminal. In the embodiment of the present invention, the programming platform further includes a message queue, and the message queue is used for temporarily storing the calculation results obtained by the computing nodes running tasks. When the service node obtains the calculation result from the calculation node to feed back the calculation result to the user terminal, the service node monitors the message queue to obtain the calculation result and feeds back the calculation result to the user terminal. Wherein, the calculation result obtained by the service node is the calculation result that the calculation node puts in the message queue.

In the embodiment of the present invention, after the service node obtains the user code used to characterize the user terminal, it establishes a session connection with the user terminal; the service node maintains the session connection with the user terminal before obtaining the calculation result; the service node After obtaining the calculation result of the computing node, the session connection with the corresponding user terminal is disconnected. Therefore, before the service node obtains the calculation result, it keeps in touch with the user terminal, so as to conveniently feed back the calculation result to the user terminal.

Through the above method, the service node obtains the user code used to represent the user terminal; puts the user code as a running task in the task queue, so that the computing node can obtain and calculate the running task from the task queue; obtain the computing node The calculation result is fed back to the user terminal to realize the operation of the user code. The service node is used to connect to the user terminal, and place the user code sent by the user terminal as a running task in the task queue, so that the computing node independent of the service node obtains and calculates the running task from the task queue to get the calculation After the result, the service node obtains the calculation result of the computing node, and feeds back the calculation result to the user terminal to realize the operation of the user code.

The invention also provides a computing node, which can also execute the user code running method of the programming platform. Please refer to FIG. 3 . FIG. 3 is a schematic flowchart of another realization of the user code running method of the programming platform provided by the embodiment of the present invention. Specifically, the method in the embodiment of the present invention includes the following steps.

Step S301 : Monitor the task queue to obtain running tasks.

The embodiment of the present invention executes the user code running method of the programming platform as the computing node in any embodiment of the above-mentioned user code running method of the programming platform. The task queue includes running tasks, and the running tasks correspond to user codes.

Computing node monitoring includes the task queue of running tasks, and obtains the running tasks corresponding to the user code one-to-one from the task queue.

The computing nodes include a first computing node and a second computing node, and the first computing node and the second computing node are located on the CPU server and the GPU server respectively, so that the first computing node monitors the dependent CPU servers in the task queue The computing and memory resources of the second computing node monitor the running tasks in the task queue that depend on the computing and memory resources of the GPU server. Specifically, the task queue may include a first task queue and a second task queue, and the first computing node and the second computing node respectively monitor the first task queue and the second task queue to obtain running tasks.

That is to say, the user code corresponds to the task queue, and when the computing node in the embodiment of the present invention is the first computing node, the running tasks of computing and memory resources in the CPU server are obtained from the first task queue; computing When the node is the second computing node, the running tasks of computing and memory resources in the GPU server are obtained from the second task queue.

Step S302: Calculate and run the task, and obtain the calculation result.

Computing nodes use the computing and memory resources on the servers they belong to to compute and run tasks and obtain computing results. After the computing node completes the calculation of the running task, it releases the corresponding computing resources and continues to monitor the task queue, that is, after the computing node completes the calculation of the current running task, it releases resources and continues to monitor the task queue to obtain new running Tasks enable computing nodes to maximize the reuse of computing and memory resources.

Through the above method, the task queue is monitored to obtain running tasks; the task queue includes running tasks, and the running tasks correspond to user codes; the running tasks are calculated to obtain calculation results, and the orderly acquisition of computing node running tasks is realized. The task queue includes the running task, and the running task corresponds to the user code, so the computing node monitors the task queue including the running task, thereby obtaining the running task corresponding to the user code, and then calculates the running task to obtain the calculation result, and realizes the running task acquisition and calculation.

The present invention also provides a programming platform, as shown in FIG. 4 , which is a schematic structural diagram of the programming platform provided by an embodiment of the present invention. Specifically, the programming platform 40 in the embodiment of the present invention includes a service node 41 , a task queue 42 , and a computing node 43 . The service node 41 is used to obtain the user code used to characterize the user terminal, and place the user code as a running task in the task queue 42; the computing node 43 is used to monitor the task queue 42 to obtain the running task; The node 43 is also used to calculate and run the task to obtain the calculation result; the service node 41 is also used to obtain the calculation result from the calculation node 43 to feed back the calculation result to the user terminal.

In the embodiment of the present invention, the number of computing nodes 43 is at least two; the computing nodes 43 are used to monitor the task queue 42, so that when running tasks, at least two computing nodes 43 are used to monitor the task queue 42, and send The queue 42 requests to obtain the running task; the task queue 42 is used to assign a running task to a computing node 43 .

In the embodiment of the present invention, the task queue 42 includes a first task queue and a second task queue, and at least two computing nodes 43 include the first computing node and the second computing node; the service node 41 is used to convert the user code When placed in the task queue 42 as a running task, it is further used to place the user code as a running task in the first task queue or the second task queue according to the calculation characteristics of the user code; the computing node 43 is used for The task queue 42 is monitored. Specifically, the first computing node monitors the first task queue, and the second computing node monitors the second task queue.

In the embodiment of the present invention, the number of service nodes 41 is at least two; when the service node 41 is used to obtain the user code used to characterize the user terminal, at least two service nodes 41 are assigned the user code through the reverse proxy .

In the embodiment of the present invention, the computing node 43 is further configured to release corresponding computing resources and continue to monitor the task queue 42 after completing the computing of the running task.

In the embodiment of the present invention, the programming platform 40 also includes a message queue 44; the service node 41 is used to obtain the calculation result from the calculation node 43, and when the calculation result is fed back to the user terminal, the calculation node 43 is also used to send the calculation result to the user terminal. The result is placed in the message queue 44; the service node 41 is also used to monitor the message queue 42 to obtain the calculation result, and feed back the calculation result to the user terminal.

In the embodiment of the present invention, the service node 41 is also used to maintain the session connection with the user terminal before obtaining the calculation result.

The service node 41 in the programming platform 40 in FIG. 4 is also used to execute the user code running method of the programming platform. Specifically, as shown in FIG. 5 , FIG. 5 is a schematic structural diagram of an embodiment of the programming platform service node 41 of the present invention. The service node 41 includes a receiving unit 411 , a placement unit 412 and an acquisition unit 413 . Wherein, the receiving unit 411 is used to obtain the user code used to characterize the user terminal; the placement unit 412 is used to place the user code as a running task in the task queue, so that the computing node can obtain and calculate the user code from the task queue. Run the task; the obtaining unit 413 is used to obtain the calculation result of the computing node, and feed back the calculation result to the user terminal.

In the embodiment of the present invention, the placing unit 412 is used to place the user code as a running task in the task queue, so that when the computing node obtains and calculates the running task from the task queue, it is also used to Computing features, placing the user code as a running task in the first task queue or the second task queue, so that the first computing node can obtain and calculate the running task from the first task queue, or the second computing node Obtain and calculate running tasks from the second task queue.

In the embodiment of the present invention, when the receiving unit 411 is used to obtain the user code used to characterize the user terminal, the user code is assigned through a reverse proxy.

In the embodiment of the present invention, the acquiring unit 413 is configured to keep the service node 41 maintaining a session connection with the user terminal before acquiring the calculation result.

The computing node 43 of the programming platform 40 in FIG. 4 is also used to execute the user code running method of the programming platform. Specifically, as shown in FIG. 6 , FIG. 6 is a schematic structural diagram of an embodiment of the computing node 43 of the programming platform of the present invention. The computing node 43 includes a monitoring unit 431 and a computing unit 432. The monitoring unit 431 is used to monitor the task queue to obtain running tasks, wherein the task queue includes running tasks, and the running tasks correspond to user codes; the computing unit 432 is used for computing Run the task and get the calculation result.

In the embodiment of the present invention, after the computing unit 432 completes the computing of the running task, the computing node 43 releases the corresponding computing resource and continues to monitor the task queue.

To further illustrate the programming platform of the present invention, please refer to FIG. 7 , which is another schematic structural diagram of the programming platform provided by the embodiment of the present invention.

In the embodiment of the present invention, the programming platform 70 includes a service node 71, a task queue 72, a computing node 73, and a message queue 74. The task queue 72 includes a first task queue 721 and a second task queue 722. The computing node 73 It 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 specific applications, the service node 71 can receive the user code of any one of the multiple user terminals, and can receive the user codes of multiple user terminals at the same time, so as to realize the acquisition of the user code used to characterize the user terminal. Code; the service node 71 performs a websocket connection with the user terminal, that is, the service node 71 acquires the user code of the user terminal through websocket communication. When the user code is placed in the task queue 72 as an execution task, if it is determined according to the calculation characteristics of the user code that the user code belongs to the first task queue 721 and will utilize the code execution resources of the CPU server 701, then the The user code is placed in the first task queue 721 as a running task, and the first computing node 731 monitors the first task queue 721 to obtain and calculate the running task to obtain the calculation result; or, if according to the calculation characteristics of the user code, If it is determined that the user code belongs to the second task queue 722 and uses the code running resources of the GPU server 702, then the user code is placed in the second task queue 722 as an execution task, and the second computing node 732 monitors the second task queue 722. The second task queue 722 obtains and calculates the running task to obtain the calculation result; both the first computing node 731 and the second computing node 732 place the calculation result in the message queue 74, and the service node 71 monitors the message queue 74 to obtain the calculation result. result, and feed back the calculation result to the corresponding user terminal. For the description of the service node 71 , the task queue 72 , the computing node 73 and the message queue 74 in the embodiment of the present invention, please refer to the above-mentioned embodiment of the programming platform, and will not repeat them here.

Through the above method, the service node places the received user code as a running task in different task queues; then the computing nodes on different servers monitor different task queues to obtain the corresponding running tasks, so as to use different computing and storage resources to calculate and run tasks to obtain calculation results, and the calculation nodes place the calculation results in the message queue; finally, the service node obtains the calculation results of the calculation nodes from the message queue, and feeds back the calculation results to the user terminal . During the entire running process of the user code, the service node and the computing node are set separately, so that the connection of the user terminal and the calculation of the user code are completed by the service node and the computing node respectively, and the computing resources of the computing node can be continuously reused, and different The computing nodes correspond to different message queues, so as to obtain user codes that rely on different computing and storage resources for calculation, realize asynchronous communication of user code operation, and improve the concurrency capability of the system.

In the embodiment of the present invention, the programming platform may be an online programming education platform or an artificial intelligence platform. For example, the programming platform is an online programming education platform, which is oriented to schools or training institutions, etc., and the user terminal is a student terminal accessing the online programming education platform to realize the operation of user codes. The online programming education platform includes service nodes, task queues and computing nodes, where the task queue is a redis list. Students enter 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 codes of multiple student terminals at the same time, so as to receive the user code sent by the students in the online programming education platform Code; the service node places the user code as a running task in the redis list for the task queue. The calculation node monitors the redis list to obtain the running tasks; and calculates the running tasks to obtain the calculation results. The service node obtains the calculation results from the computing nodes to feed back the calculation results to the student terminals.

In the embodiment of the present invention, 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 computing node and a message queue, wherein the task queue is a redis list and includes the first task queue and the second task queue; the computing node includes the first computing node and The second computing node; the message queue is RabbitMQ. The service node of the online programming education platform determines that the user code belongs to the first task queue according to the calculation characteristics of the user code and uses the code running resources of the CPU server, then puts the user code as the running task in the first task queue In a task queue, the first calculation node monitors the first task queue to obtain and calculate the running tasks, and obtains the calculation result; or, the service node determines that the user code belongs to the second task queue according to the calculation characteristics of the user code and To use the code of the GPU server to run resources, the user code is placed in the second task queue as a running task, and the second computing node monitors the second task queue to obtain and calculate the running task, and obtain the calculation result; the first Both the calculation node and the second calculation node place the calculation results in the message queue RabbitMQ, and the service node monitors the RabbitMQ to obtain the calculation results, and feeds back the calculation results to the corresponding student terminals.

Through the above method, for schools or training institutions, etc., the online programming education platform can satisfy a larger number of students to simultaneously learn online programming on the online programming education platform, realize full use of computing power resources, and save costs.

Please refer to FIG. 8 . FIG. 8 is a schematic frame diagram of an embodiment of the electronic device of the present invention. Specifically, the electronic device 800 in the embodiment of the present invention includes a memory 810 and a processor 820 coupled to each other. Wherein, the memory 810 is used for storing program instructions and data required to be stored by the processor 820 during processing.

The processor 820 controls the memory 810 and itself to implement the steps of any embodiment of the above-mentioned user code running method of the programming platform. The processor 820 may also be referred to as a CPU (Central Processing Unit, central processing unit). The processor 820 may be an integrated circuit chip with signal processing capability. The processor 820 can also be a general-purpose processor, a digital signal processor (Digital Signal Processor, DSP), an application specific integrated circuit (Application Specific Integrated Circuit, ASIC), a field-programmable gate array (Field-Programmable Gate Array, FPGA) Or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components. A general-purpose processor may be a microprocessor, or the processor may be any conventional processor, or the like. In addition, the processor 820 may be jointly implemented by multiple circuit chips.

Please refer to FIG. 9 . FIG. 9 is a schematic frame diagram of an embodiment of the storage device of the present invention. The storage device 900 of the present invention stores program instructions 901 that can be executed by the processor, and the program instructions 901 are used to implement the steps in the embodiments of the user code running method of any programming platform described above.

The storage device 900 can specifically be a U disk, a mobile hard disk, a read-only memory (ROM, Read-Only Memory), a random access memory (RAM, Random Access Memory), a magnetic disk or an optical disk, etc., which can store program instructions 901 media (including volatile storage media or non-volatile storage media), or a server that stores the program instructions 901, and the server can send the stored program instructions 901 to other devices for execution, or The stored program instructions 901 can be self-executed.

In the several embodiments provided by the present invention, it should be understood that the disclosed methods and devices can be implemented in other ways. For example, the device implementations described above are only illustrative. For example, the division of modules or units is only a logical function division. In actual implementation, there may be other division methods. For example, multiple units or elements can be combined or May be integrated into another system, or some features may be ignored, or not implemented. In another point, the mutual coupling or direct coupling or communication connection shown or discussed may be through some interfaces, and the indirect coupling or communication connection of devices or units may be in electrical, mechanical or other forms.

A unit described as a separate component may or may not be physically separated, and a component displayed as a unit may or may not be a physical unit, that is, it may be located in one place, or may be distributed to multiple network units. Part or all of the units can be selected according to actual needs to achieve the purpose of the solution of this embodiment.

In addition, each functional unit in each embodiment of the present invention may be integrated into one processing unit, each unit may exist separately physically, or two or more units may be integrated into one unit. The above-mentioned integrated units can be implemented not only in the form of hardware, but also in the form of software functional units.

If the integrated unit is realized in the form of a software function unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the essence of the technical solution of the present invention or the part that contributes to the prior art or all or part of the technical solution can be embodied in the form of a software product, which is stored in a storage medium. Several instructions are included to make a computer device (which may be a personal computer, a server, or a network device, etc.) or a processor (processor) execute all or part of the steps of the methods in various embodiments of the present invention. The aforementioned storage media include: U disk, mobile hard disk, read-only memory (ROM, Read-Only Memory), random access memory (RAM, Random Access Memory), magnetic disk or optical disk, etc., which can store program codes. medium.

Industrial Applicability The invention discloses a user code running method of a program design platform, electronic equipment and a computer-readable storage medium. Among them, the programming platform includes service nodes, task queues, and computing nodes; the user code running method of the programming platform includes: the service node obtains the user code used to represent the user terminal, and places the user code as a running task In the task queue; the computing node monitors the task queue to obtain the running task; the computing node calculates the running task and obtains the calculation result; the service node obtains the calculation result from the computing node to feed back the calculation result to the user terminal.

40:Programming platform 41: service node 411: receiving unit 412: Place unit 413:Get unit 42: Task Queue 43:Compute node 431: Monitoring unit 432: Calculation unit 44: Message queue 70:Programming platform 701: CPU server 702:GPU server 71: service node 72: Task Queue 721: The first task queue 722: The second task queue 73:Compute node 731: The first computing node 732: The second computing node 74: Message queue 800: Electronic equipment 810: Memory 820: Processor 900: storage device 901: Program instruction S101~S104, S201~S203, S301~S302: steps

The accompanying drawings here are incorporated into the specification and constitute a part of the specification. These drawings show embodiments consistent with the present invention, and are used together with the description to illustrate the technical solutions of the embodiments of the present invention. FIG. 1 is a schematic flow diagram of a user code running method of a programming platform provided by an embodiment of the present invention; FIG. 2 is a schematic diagram of another implementation flow of the user code running method of the programming platform provided by the embodiment of the present invention; FIG. 3 is a schematic flow diagram of another realization of the user code running method of the programming platform provided by the embodiment of the present invention; Fig. 4 is a schematic structural diagram of a programming platform provided by an embodiment of the present invention; FIG. 5 is a schematic structural diagram of a programming platform service node 41 provided by an embodiment of the present invention; FIG. 6 is a schematic structural diagram of a programming platform computing node 43 provided by an embodiment of the present invention; Fig. 7 is another structural schematic diagram of the programming platform provided by the embodiment of the present invention; Fig. 8 is a schematic frame diagram of an electronic device provided by an embodiment of the present invention; Fig. 9 is a schematic frame diagram of a storage device provided by an embodiment of the present invention.

S101~S104: steps

Claims (12)

A user code running method of a programming platform, the programming platform includes: a service node, a task queue, and a computing node; the method includes: the service node obtains a user code used to characterize a user terminal, and According to the calculation characteristics of the user code, the user code is placed as a running task in the first task queue or the second task queue; in the first task queue and the second task queue The running tasks of are calculated depending on different code resources; the first computing node monitors the first task queue, and the second computing node monitors the second task queue to obtain the running tasks; the first The computing node and the second computing node respectively have different computing resources and storage resources; the first computing node or the second computing node calculates the running task and obtains a calculation result; the service node obtains a calculation result from the The first calculation node or the second calculation node obtains the calculation result, and feeds the calculation result back to the user terminal. According to the method described in claim 1, wherein, the number of the service nodes is at least two; the service node obtains the user code used to characterize the user terminal, including: at least two of the service nodes pass the reverse Agents are assigned the user code. According to the method described in claim 1 or 2, wherein, the After the first computing node or the second computing node finishes computing the running task, it releases the corresponding computing resource and continues to monitor the corresponding task queue. The method according to claim 1, wherein the programming platform further includes a message queue; the service node obtains the calculation result from the first computing node or the second computing node, and sends the The calculation result is fed back to the user terminal, including: the first calculation node or the second calculation node places the calculation result in the message queue; the service node monitors the message queue to The calculation result is obtained, and the calculation result is fed back to the user terminal. The method according to claim 4, wherein the service node maintains a session connection with the user terminal before obtaining the calculation result. A method for running a user code on a programming platform, the method comprising: obtaining a user code used to characterize a user terminal; according to the calculation characteristics of the user code, placing the user code as an execution task in the first A task queue or a second task queue, so that the first computing node obtains and calculates the running task from the first task queue, or the second computing node obtains and calculates the running task from the second task queue Acquire and calculate the running tasks; the running tasks in the first task queue and the second task queue are calculated depending on different code resources; the first computing node and the second computing node have different computing resources and storing resources; obtaining calculation results of the first computing node or the second computing node, and feeding back the computing results to the user terminal. The method according to claim 6, wherein said acquiring a user code used to characterize the user terminal comprises: being assigned the user code through a reverse proxy. The method according to claim 6, wherein the method includes: maintaining a session connection with the user terminal before obtaining the calculation result. A user code running method for a programming platform, the method comprising: monitoring a corresponding task queue to obtain a running task; the corresponding task queue includes the running task, and the running task corresponds to the use or codes; different task queues correspond to different computing nodes; the running tasks in different task queues depend on different code resources when being calculated; different computing nodes have different computing resources and storage resources; task to get the calculation result. The method according to claim 9, wherein the method includes: after the calculation of the running task is completed, releasing the corresponding computing resource and continuing to monitor the corresponding task queue. An electronic device, comprising a memory and a processor coupled to each other; the processor is used to execute the program instructions stored in the memory to implement the method described in any one of claims 1 to 5; and/or, with Implement the requested item The method described in any one of 6 to 8; and/or, to realize the method described in claim 9 or 10. A computer-readable storage medium, storing a computer program that can be executed to implement the user code execution method of the programming platform as described in any one of claims 1 to 5; and/or, storing a computer program that can be executed to implement The computer program of the user code running method of the programming platform as described in any one of claim items 6 to 8; and/or, storing the user that can be executed to realize the programming platform as described in claim item 9 or 10 A computer program whose code runs the method.

Images