KR20210105378A - How the programming platform's user code works and the platform, node, device, medium - Google Patents

Abstract

This application discloses a method and platform, node, device, medium for operating user code of a programming platform. Here, the programming platform includes a service node, a work queue, and a computation node; The method includes the steps of: a service node obtaining a user code for representing a user terminal, and placing the user code in a work queue as an operation task; the computing node monitoring the work queue to obtain working work; calculating, by the computation node, an operation task to obtain a computation result; and obtaining, by the service node, a calculation result from the calculation node, and feeding back the calculation result to the user terminal.

Description

How the programming platform's user code works and the platform, node, device, medium

This application is filed on the basis of a Chinese patent application with an application number of 202010093681.6 with an application date of February 14, 2020, and claims the priority of the Chinese patent application, all contents of the Chinese patent application are hereby incorporated by reference is cited in

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

With the rapid development of artificial intelligence, various systems that rely on code to operate have also been created. Not only is the code more and more diverse, but the requirements for the functions that the system can provide are also increasing.

In the face of increasingly complex codes, in the current programming platform, the execution environment of the code, such as the Kernel (execution environment), often needs to maintain a connection relationship with the user terminal, as well as calculate the code sent by the user terminal. , the system capability cannot satisfy the code operation requirements.

Based on this, how to improve the parallel ability of programming platforms to run user code has become an urgent problem.

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

The programming platform of the present application includes a service node, a work queue, and a computation node. A first aspect of the present application provides a method for operating a user code of a programming platform, the method comprising: the service node obtains a user code for representing a user terminal, and placing the user code as an activation job in the job queue to do; monitoring, by the computation node, the work queue to obtain the working work; calculating, by the computation node, the operation task to obtain a computation result; and obtaining, by the service node, the calculation result from the calculation node, and feeding back the calculation result to the user terminal.

Accordingly, the service node implements the connection with the user terminal, places the user code in a queue, and the calculation of the user code is performed by the calculation node, thereby implementing the operation of the user code. During the operation of the user code, the service node is installed separately from the calculation node, 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 that asynchronous communication operated by the user code is performed. Implement and improve the parallelism capability of the system.

Here, the number of the computation nodes is at least two; The step of the computation node monitoring the work queue to obtain the working task may include: at least two of the computation nodes monitoring the work queue and requesting the work queue to acquire the working task; and partitioning, by the work queue, one of the work tasks to the computation nodes.

Therefore, when a plurality of computation nodes monitor all the working tasks in the work queue, the plurality of computation nodes all request the work queue to acquire the working tasks, the work queue splits the working tasks into one computation node, , through the work queue, a reasonable allocation of working tasks can be completed.

wherein the work queue includes a first work queue and a second work queue, and at least two of the computation nodes include a first computation node and a second computation node; placing the user code in a work queue as a working task includes placing the user code in a first work queue or a second work queue as a working task, according to a computational characteristic of the user code; The step of the computation node monitoring the work queue includes: the first computation node monitoring the first work queue, and the second computation node monitoring the second work queue.

Therefore, the service node can distinguish the user code based on the computational characteristics of the user code, and place it in the first work queue or the second work queue, respectively, so that different computation nodes monitor different work queues, so that the user code is Differentiate and process user codes according to different operation requirements.

Here, the number of service nodes is at least two; The step of obtaining, by the service node, a user code for representing a user terminal, includes the step of at least two of the service nodes being assigned the user code by a reverse proxy.

Accordingly, the present application may provide at least two service nodes, and the service nodes implement user codes distributed by a reverse proxy, such that a plurality of service nodes receive the user codes transmitted by the user terminals in parallel. improve processing power;

Here, after the computation node completes the calculation for the working task, it releases the corresponding computational resource and continues to monitor the task queue.

Therefore, the compute node releases the resource as soon as the computation is completed, continues to monitor the work queue to acquire a new working task, and the compute node releases the resource as soon as it completes the running task, so that the computation and built-in memory resources are redundantly used. As much as possible, make full and reasonable use of hardware resources.

wherein the programming platform further comprises a message queue; The step of the service node obtaining the calculation result from the calculation node and feeding back the calculation result to the user terminal may include: placing, by the calculation node, the calculation result in the message queue; and the service node monitoring the message queue, obtaining the calculation result, and feeding back the calculation result to the user terminal.

Therefore, after the computation node finishes executing the operation task corresponding to the arbitrary user code, the computation result is batched in the message queue, and the message queue is monitored by the service node to obtain the computation result of the computation node. Therefore, the calculation results are also managed collectively.

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

Accordingly, the service node maintains the session connection with the user terminal before obtaining the calculation result, that is, maintains the connection between the service node and the user terminal, so that it is easy to feed back the calculation result to the user terminal.

A second aspect of the present application provides a method of operating a user code of a programming platform, the method comprising: obtaining a user code for indicating a user terminal; placing the user code in a work queue as a working job, so that the working job is obtained and calculated from the work queue by a computation node; and obtaining a calculation result of the calculation node, and feeding back the calculation result to the user terminal.

Therefore, the service node is used for connection with the user terminal, and puts the user code sent by the user terminal into the work queue as a working job, so that a computation node independent of the service node obtains and calculates the working job from the work 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 implement the operation of the user code.

wherein the step of placing the user code in a work queue as an actuation task, whereby the actuation task is obtained and calculated from the work queue by a computation node, comprises, according to a calculation characteristic of the user code, the user code as an actuation task. placing in a first work queue or a second work queue, wherein the working task is obtained and calculated from the first work queue by a first computation node, or the operational task is retrieved from the second work queue by a second computation node obtained and calculated.

Therefore, the service node can distinguish the user code based on the computational characteristics of the user code, and place it in the first work queue or the second work queue, respectively, so that different computation nodes monitor different work queues, so that the user code is Differentiate and process user codes according to different operation requirements.

Here, the step of obtaining the user code for indicating the user terminal includes the step of allocating the user code through a reverse proxy.

Accordingly, the service node is assigned the user code by the reverse proxy, thereby rationally assigning the user code sent by the user terminal that the service node receives.

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

Accordingly, the service node maintains the session connection with the user terminal before obtaining the calculation result, that is, maintains the connection between the service node and the user terminal, so that it is easy to feed back the calculation result to the user terminal.

A third aspect of the present application provides a method of operating a user code of a programming platform, the method comprising: monitoring a job queue to obtain a working job, wherein the job queue includes the working job, the working task comprising: Corresponding to the user code - ; and calculating the operation operation to obtain a calculation result.

Therefore, since the work queue contains an actuation task, and an actuation task corresponds to a user code, the computation node calculates the actuation task by monitoring the work queue containing the actuation task, by obtaining the actuation task corresponding to the user code, Since the calculation result is obtained, the acquisition and calculation of the operation task are implemented.

Here, the user code operation method of the programming platform further includes, after completing the calculation for the operation task, releasing a corresponding computational resource and continuously monitoring the task queue.

Therefore, the compute node releases the resource as soon as the computation is completed, and continues to monitor the work queue to obtain a new working task, so that user code can be executed on a different computation node, and the computation node immediately releases the resource upon completing the running task. to make redundant use of computational and built-in memory resources, making full and reasonable use of hardware resources.

A fourth aspect of the present application provides a programming platform, comprising: a service node, a work queue, a computation node; the service node is configured to obtain a user code for indicating a user terminal, and place the user code as an operation task in the work queue; the computing node is configured to monitor the work queue to obtain the working work; the calculation node is also configured to calculate the operation task to obtain a calculation result; The service node is further configured to obtain the calculation result from the calculation node, and feed back the calculation result to the user terminal.

Here, the number of the computation nodes is at least two; when the computing node is configured to monitor the work queue and obtain the working job, at least two of the computing nodes are configured to monitor the work queue and request the work queue to acquire the working job; The work queue is configured to assign the working work to the compute node.

wherein the work queue includes a first work queue and a second work queue, and at least two of the computation nodes include a first computation node and a second computation node; When the service node is for placing the user code in a work queue as an actuation task, specifically, the service node sets the user code as an actuation task into a first work queue or a second work queue, according to a computational characteristic of the user code. for placement in the work queue; The computation node is for monitoring the work queue, specifically, the first computation node is for monitoring the first work queue, and the second computation node is for monitoring the second work queue.

Here, the number of service nodes is at least two; When the service node is configured to obtain a user code for representing a user terminal, at least two of the service nodes are configured to be assigned the user code by a reverse proxy.

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

wherein the programming platform further comprises a message queue; when the service node is configured to obtain the calculation result from the calculation node and feed back the calculation result to the user terminal, the calculation node is configured to place the calculation result in the message queue; The service node is configured to monitor the message queue, obtain the calculation result, and feed back the calculation result to the user terminal.

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

A fifth aspect of the present application provides a service node, wherein the service node includes a receiving unit, a deploying unit and an obtaining unit, wherein the receiving unit is configured to obtain a user code for indicating a user terminal; the placing unit is configured to place the user code as a working job in a work queue, so that the working job is obtained and calculated from the work queue by a computing node; The obtaining unit is configured to obtain a calculation result of the calculation node, and feed back the calculation result to the user terminal.

wherein, when the placing unit is configured to place the user code in a work queue as an actuation task, so that the actuation task is obtained and calculated from the work queue by a computation node, also according to a calculating feature of the user code, the placing user code in a first work queue or a second work queue as an actuation task so that the actuation task is obtained and computed from the first work queue by a first computation node, or the second task is obtained by a second computation node The actuation task is obtained from a queue and configured to be calculated.

Here, when the receiving unit is configured to obtain a user code for indicating a user terminal, the user code is also configured to be assigned through a reverse proxy.

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

A sixth aspect of the present application provides a computation node, wherein the computation node includes a monitoring unit and a computation unit, wherein the monitoring unit is configured to monitor the work queue to obtain an operation task; wherein the job queue includes the working job, the working job corresponding to the user code; The calculation unit is configured to calculate the operation operation to obtain a calculation result.

Here, the calculating unit is configured to, after completing the calculation of the working task, also release the corresponding computational resource and continue to monitor the work queue.

A seventh aspect of the present application provides an electronic device, the electronic device comprising a memory and a processor coupled to each other; the processor executes program instructions stored in the memory, the method of operating a user code of the programming platform of the first aspect; a method of operating user code of the programming platform of the second aspect; and a method of operating a user code of a programming platform of the third aspect.

Accordingly, the service node is for implementing a connection with the user terminal, placing the user code in a queue, and the computation node is used to calculate the user code, thereby implementing the operation of the user code. During the operation of the user code, the service node is installed separately from the calculation node, 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 that asynchronous communication operated by the user code is performed. Implement and improve the parallelism capability of the system.

An eighth aspect of the present application provides a computer-readable storage medium, wherein the storage medium stores program instructions operable by a processor, the program instructions comprising: a method of operating a user code of the programming platform of the first aspect; a method of operating user code of the programming platform of the second aspect; and a method of operating a user code of a programming platform of the third aspect.

Therefore, during the operation of the user code, the service node is for implementing a connection with the user terminal, and the calculation node is for implementing the calculation of the user code, so that the asynchronous communication operated by the user code is implemented, and the system improve the parallel ability of

The drawings below constitute the entire specification as a part of the present specification, and these drawings illustrate embodiments suitable for the present application, and are for explaining the technical solutions of the embodiments of the present application together with the specification.
1 is an exemplary implementation flow diagram of a user code operation method of a programming platform provided in an embodiment of the present application.
2 is an exemplary flow diagram of another implementation of the user code operation method of the programming platform provided in the embodiment of the present application.
3 is another implementation flow diagram of a user code operation method of a programming platform provided in an embodiment of the present application.
4 is an exemplary structural diagram of a programming platform provided in an embodiment of the present application.
5 is an exemplary structural diagram of the programming platform service node 41 provided in the embodiment of the present application.
6 is an exemplary structural diagram of the programming platform computation node 43 provided in the embodiment of the present application.
7 is a diagram illustrating another structure of a programming platform provided in an embodiment of the present application.
8 is an exemplary architecture diagram of an electronic device provided in an embodiment of the present application.
9 is an architectural diagram of a storage device provided in an embodiment of the present application.

Various exemplary embodiments, features and aspects of embodiments of the present application will be described in detail below with reference to the drawings. In the drawings, the same reference numerals indicate components having the same or similar functions. While various aspects of the embodiments are illustrated in drawings, the drawings are not necessarily drawn to scale unless specifically stated otherwise.

In conjunction with the drawings of the specification below, the method of the embodiment of the present application will be described in detail.

Hereinafter, in conjunction with the accompanying drawings of the embodiments of the present invention, it is clearly and completely described for the technical solutions in the embodiments of the present invention, and it is clear that the described embodiments are only some embodiments of the present invention and not all embodiments. do. Based on the embodiments of the present application, all other embodiments obtained by those skilled in the art without creative labor should fall within the protection scope of the present application. In this specification, "first", "second", etc. are only for explaining the purpose, and cannot be understood as indicating or implying relative importance or implicitly indicating the number of designated technical features.

In some embodiments, with the prevalence of artificial intelligence, machine learning and artificial intelligence programming education also increasingly become an important component of programming education. Different from general introductory programming education, artificial intelligence code executed by students during artificial intelligence programming education often has to implement a large amount of computation, and (central processing unit)CPU/GPU(Graphics Processing Unit, graphics processing unit) The corresponding resource overhead, such as device) occupancy, internal memory space, etc., is also large. In the programming education platform of the related technology, one independent Kernel is created for each user and stored in the server internal memory, so that each user can perform programming experiments in the created independent Kernel. As a result, the overhead of resources required by the artificial intelligence code is large, so that each kernel occupies a large amount of CPU/GPU resources and internal memory space. If each user's kernel resides in the internal memory, the overall overhead is large, resource utilization is low; In addition, since each user and Kernel have a strict one-to-one correspondence, the number of users who can simultaneously perform online programming learning is not limited to the number of Kernels supported by the server; Since the environment does not change when each user's Kernel process operates, it is not possible to flexibly schedule and execute it on different machines depending on the resource occupancy situation of user code. It is disadvantageous in improving system parallelism ability. As a result, in artificial intelligence online programming education, the server cost overhead rises sharply, making it difficult to promote and popularize.

Based on this, an embodiment of the present application provides a method of operating a user code of a programming platform, through building a group of equal service nodes and a group of equal computation nodes, after the user submits the code, It transmits user code to any one service node through full duplex protocol (websocket) technology. The service node creates a working job, puts it in the job queue, and maintains the current session connection, and any computation node gets the working job from the job queue, executes user code, and puts the execution result into the job queue in real time. feedback to the corresponding service node through the The service node reads and accesses the execution result from the work queue and pushes it to the user terminal in real time through the full duplex protocol, and ends the current session after completing the push. Here, the service node supports multi-task parallel connection, and the compute node supports single-task execution.

An implementation flow of the method is as shown in FIG. 1 , and FIG. 1 is an exemplary implementation flow diagram of a user code operation method of a programming platform provided in an embodiment of the present application. Specifically, the embodiment method of the present application includes the following steps.

In step S101, the service node obtains a user code for representing the user terminal, and places the user code as an operation job in the work queue.

The programming platform of the embodiment of the present application includes a service node, a work queue and a computation node.

The service node may acquire the user code of any one user terminal among the plurality of user terminals, and may simultaneously acquire the user codes of the plurality of user terminals, thereby supporting parallel connection of multiple user terminals. The service node may be implemented by any electronic device having a processing function, such as a server or a computer. Here, the electronic device may also be used to execute other functions, for example, the electronic device may also be used to execute the calculation of the operation task obtained by the computation node, that is, the service node and the computation node are the same electronic device. It may be implemented by a device or may be implemented by a different electronic device. A manner in which the service node receives the user code includes, but is not limited to, a websocket communication technology and a Hyper Text Transfer Protocol (HTTP) communication technology, and is not specifically limited thereto. The source of the user code received by the service node may vary, for example, the code editing window of the user terminal itself obtains the code edited by the user to form the user code, or the user terminal itself and Receiving user codes sent by connected code editing devices, and so on.

In an embodiment of the present application, the number of service nodes is at least two. When the service node obtains the user code for representing the user terminal, at least two service nodes are assigned the user code by the reverse proxy. This service node opens a service for the front-end application, and communicates between the front-end application and the service node using a full duplex communication protocol, and the service node receives the user code of the user terminal assigned by the reverse proxy server, , Here, the user code of the user terminal indicates identifier information of the user terminal, for example, a sequence number of the user terminal, or a user account of the user terminal. Implement the user code assignment between the user terminal and at least two service nodes by using a reverse proxy server, and when the reverse proxy server obtains the user code of the user terminal, immediately assign the user code to at least two service nodes. This ensures that each service node is assigned a user code by a reverse proxy. Similarly, the service node may simultaneously receive user codes of a plurality of user terminals, thereby supporting parallel connection of multiple user terminals.

After the service node receives the user code, it creates a working task for each user code, and places the working task in the work queue, so that the work queue contains all the working tasks that correspond one-to-one to the user code placed by the service node. . The array queue may be a storage system such as a remote dictionary service (Remote Dictionary Server, Redis) list, or a message-oriented middleware such as a message queue (Message Queue, RabbitMQ).

In the embodiment of the present application, the operation task corresponding to the user code is separately arranged according to the resource-dependent demand of the user code. Specifically, the work queue includes a first work queue and a second work queue, and when the working work in the first work queue and the second work queue is calculated, it depends on different code resources, for example, the first work The operation job in the queue depends on the CPU code to operate the environment resource, and the operation job in the second job queue depends on the GPU code to operate the environment resource. The assignment of working tasks in the first work queue and the second work queue is determined by a computational characteristic of the user code, that is, the computational characteristic is for indicating that the user code belongs to the first work queue or the second work queue. . Here, the expression form of the calculation feature includes, but is not included in, a character string identifier of a predetermined bit length in the user code, a binary code, and the like. Thereby, when the service node places the user code in the working queue as the working job, it places the user code in the first working queue or the second working queue as the working job, according to the calculation characteristics of the user code.

In an embodiment of the present application, the work queue may include at least two sub work queues, and a relationship between the service node and the plurality of sub work queues may be established in advance, and the service node may be configured to represent a user terminal. Acquire a user code, and place the user code in different sub-task queues as a working task, or establish an association relationship between a plurality of service nodes and a plurality of sub-task queues, and some service nodes associate the received user code with them. Allocate to some sub-work queues that have been built, and some other service nodes allocate the received user code to some other sub-work queues that have established a relationship therewith, and implement a corresponding relationship between the service node and the work queue.

In step S102, the computation node monitors the work queue to obtain a working job.

By including the working task in the work queue, the computation node can monitor the work queue, and when the work queue includes a running task executable by the computation node, it can obtain the working task immediately. The manner in which the compute node acquires the working job from the work queue is that the work queue actively allocates the working work to the compute node, or the compute node requests the work queue to acquire the working job, and the work queue receives the working work according to the request. to a compute node, but is not limited thereto.

In an embodiment of the present application, the number of computation nodes is at least two. when the computing node monitors the work queue to obtain a working job, at least two computing nodes monitor the work queue, and request the work queue to acquire the working job; The work queue assigns working tasks to the compute nodes, so that the work queue completes the rational allocation of working tasks. The rule that the work queue assigns operational tasks to computational nodes can be customized, for example, it pre-stores the priority level of all computational nodes, and the task queue allows multiple computational nodes to acquire the same operational task. When the request is received at the same time, the operation task is assigned to the higher-level computation node first; Alternatively, the operation task is allocated to the computational node that has obtained the least operation task within a preset time period, and is not specifically limited thereto.

In an embodiment of the present application, when the work queue includes the first work queue and the second work queue, and the compute node includes the first compute node and the second compute node, the computation node monitors the work queue. may specifically be that the first compute node monitors the first work queue, and the second compute node monitors the second work queue, so that different compute nodes monitor different work queues, respectively, to implement and manage It is easy and improves the acquisition efficiency of the operation operation. Here, the first computation node and the second computation node may be located in servers of different configurations, respectively, and thus have different computation and storage resources, respectively, and thus may implement computation of different user codes. In the case of the computation of user code, when the user code is calculated by the computation feature, the computation and storage resources that depend on it can be obtained, that is, the computation feature of the user code means that the user code is placed in the first work queue or the second work queue. By indicating belonging, the user code is located in the first computation node or the second computation node of the server of a different configuration to instruct to calculate.

Further, the first computation node is installed in the CPU server, and the second computation node is installed in the GPU server; the first work queue includes operational tasks that depend on the CPU code to operate the environmental resource, and the second task queue includes the operational task that depends on the GPU code to operate the environmental resource; A first computation node in the CPU server monitors the first work queue to obtain an operational task, and a second computation node in the GPU server monitors the second task queue to obtain an operational task.

In step S103, the calculation node calculates an operation task to obtain a calculation result.

The computation node uses the computation and internal memory resources available in the server where it is located, and calculates the obtained operation task, so that the computation result can be obtained. After the compute node completes the calculation of the working task, it releases the corresponding computational resource and continues to monitor the work queue, that is, the compute node releases the resource as soon as it completes the calculation of the current working task, and continues the work queue. By monitoring, it acquires new operational tasks, so that the compute node maximizes multiplexing of computational and internal memory resources. Here, in the present application, whether the computation node may acquire any working task among the work queues, or the first computation node and the second computation node acquire the operational tasks of the first work queue and the second work queue, respectively, the same All compute nodes can release resources as soon as they finish executing the working tasks, so as to continuously acquire new working tasks, as long as the computational and internal memory resources of the compute nodes match the working environment resources of user code. Therefore, the user code can be executed in different computation nodes, so that the computation and internal memory resources of the computation node are redundantly used, so that the hardware resources of the server are sufficiently and rationally used.

As mentioned above, the service node places the user code in the first work queue or the second work queue as the working work according to the computational characteristics of the user code; the first computation node and the second computation node obtain operational tasks from the first work queue and the second work queue, respectively; The first computation node and the second computation node in the servers of different configurations calculate operation tasks by using their own computation and internal memory resources, respectively, to obtain a computation result. Therefore, the work queue operates by dividing the working work into the computation nodes according to the actual demand of the user code, and the computation nodes belong to the servers of different configurations, thereby realizing the rational use of resources. For example, the first work queue is a CPU work queue, the second work queue is a GPU work queue, the first compute node and the second compute node are located in the CPU server and the GPU server, respectively, and the first compute node is the first compute node. 1 obtains and calculates the working job from the work queue, and the second computation node obtains and calculates the working job from the second work queue. Specifically, the computational feature of the user code indicates that the corresponding user code belongs to the first work queue, and the first computation node acquires the working task from the first work queue, and uses computation and internal memory resources in the CPU server. Calculating the operation operation using Compute nodes on a CPU server can execute common code that does not depend on GPU server resources, and compute nodes on GPU servers use GPU server resources, including, but not limited to, neural network model training, image processing, etc. code can be executed.

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

After the calculation node calculates the operation task to obtain the calculation result, the service node may obtain the calculation result from the calculation node, and may feed back the calculation result to the user terminal. The manner in which the service node obtains the calculation result from the calculation node includes, but is not limited to, obtaining a request, subscribing, and the like, and is not specifically limited herein. When the manner in which the service node obtains the calculation result from the calculation node is to obtain a request, the service node monitors the calculation node, and sends an acquisition request for obtaining the calculation result to the calculation node, and the corresponding calculation node sends an acquisition request The calculation result is fed back to the service node according to When the method in which the service node obtains the calculation result from the calculation node is subscription, the calculation node calculates the operation task to obtain the calculation result, and then directly feeds back the calculation result to the service node.

In an embodiment of the present application, the programming platform further includes a message queue, wherein the message queue is for temporarily storing the calculation result obtained by the calculation node calculating the operation work. A message queue may be a storage system such as a Redis list, or a message-oriented middleware such as RabbitMQ. When the message-oriented service node obtains the calculation result from the calculation node and feeds back the calculation result to the user terminal, the calculation node places the calculation result in a message queue; The service node monitors the message queue, obtains a calculation result, and feeds 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 to the calculation result of the calculation node from the message queue and feeds back the calculation result to the user terminal through communication technology such as websocket do.

In the embodiment of the present application, the service node obtains the user code for indicating the user terminal, and then establishes a session connection with the user terminal; The service node maintains a session connection with the user terminal before obtaining the calculation result; After the service node obtains the calculation result of the calculation node, it blocks the session connection with the corresponding user terminal. Accordingly, since the service node continues to maintain the association between the service node and the user terminal before obtaining the calculation result, it is easy to feed back the calculation result to the user terminal. During the operation of the user code, the service node is installed separately from the calculation node, and 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 long connection between the user terminal and the session, the computation node completes the calculation of the working task, releases the corresponding computational resource, and continues to monitor the task queue, so that the computational node constantly overlaps the computational resource. Therefore, there is no need to continuously occupy the computation node during the operation of the user code, implement asynchronous communication operated by the user code, and improve the parallelism capability of the system. A computation node acquires and calculates a working task to obtain a computation result, then releases the corresponding computational resource, and continues to acquire a new operational task, so that the computational node's computational resource is not continuously occupied, so that the computational resource of the same computational node By implementing this overlapping use, the resource utilization rate is improved.

Through the above method, the programming platform includes a service node, a work queue and a computation node, so that the service node and the computation node are installed separately, the service node acquires a user code for representing the user terminal, and operates the user code placed in the work queue as; the computation node monitors the work queue to obtain operational tasks; The computation node computes the operation task, and obtains a computation result; The service node obtains the calculation result from the calculation node, and feeds back the calculation result to the user terminal, so that the service node implements a connection with the user terminal, and the calculation node implements the calculation of the user code, thereby implementing the operation of the user code do. In addition, during the operation of the user code, the service node is installed separately from the calculation node, 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 that asynchronous communication operated by the user code is performed. Implement and improve the parallelism capability of the system.

The present application further provides a service node, which can likewise execute a user code operating method of a programming platform. Referring to FIG. 2 , FIG. 2 is another implementation flow diagram of a user code operation method of a programming platform provided in an embodiment of the present application. Specifically, the embodiment method of the present application includes the following steps.

In step S201, a user code for indicating a user terminal is obtained.

Executing the user code operating method of the programming platform in the embodiment of the present application is the service node in any one embodiment of the user code operating method of the programming platform. The programming platform includes service nodes, work queues and compute nodes.

Since the service node may receive the user code of any one user terminal among the plurality of user terminals and may simultaneously receive the user codes of the plurality of user terminals, it supports parallel connection of multiple user terminals. Methods in which the service node receives the user code include, but are not limited to, websocket communication technology and HTTP communication technology, and are not specifically limited herein. The origin of the user code received by the service node may vary. For example, the code editing window of the user terminal itself obtains the code edited by the user to obtain the user code, or the user terminal receives the user code transmitted by the code editing device connected thereto.

In the embodiment of the present application, the service node is assigned the user code by the reverse proxy, so that the user terminal and the service node do not need to establish a one-to-one correspondence, so that the user code of the user terminal is changed by the reverse proxy server. Allocation is performed.

In step S202, the user code is placed in the work queue as the working job, so that the working job is obtained and calculated from the working queue by the calculation node.

The service node places the user code in the work queue as a working task, so that the working tasks in the work queue are allocated in batches, so the system's ability to respond concurrently can be improved through the arrangement mechanism. The service node only needs to obtain the user code of the user terminal, maintain a session connection with the user terminal, and implement the connection with the user terminal, in the case of the user code, after placing the work queue as an operation task, The operation task is obtained and calculated from the work queue by the computation node, so that the connection of the user terminal and the computation of the user code are completed by the service node and the computation node, respectively, to implement asynchronous communication operated by the user code, the system improve the parallel ability of

In an embodiment of the present application, the work queue includes a first work queue and a second work queue, and the computation node includes a first computation node and a second computation node. The service node places the user code as a working job in the work queue, so that when the working job is obtained and calculated from the work queue by the computation node, the user code is placed in the first job queue or By placing in the second work queue, the working job is obtained and calculated from the first work queue by the first computing node, or the working job is obtained and calculated from the second work queue by the second computing node.

For descriptions related to the remaining steps S201 and S202, reference may be made to the above steps S101 to S103, which will not be repeated any longer.

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

After the calculation node obtains the calculation result, the service node may obtain the calculation result from the calculation node, and may feed back the calculation result to the user terminal. In an embodiment of the present application, the programming platform further includes a message queue, and the message queue is for temporarily storing the calculation result obtained by the calculation node calculating the operation task. When the service node obtains 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 obtain the calculation result, and feeds back the calculation result to the user terminal. Here, the calculation result obtained by the service node is that the calculation node places the calculation result in the message queue.

In the embodiment of the present application, the service node obtains the user code for indicating the user terminal, and then establishes a session connection with the user terminal; The service node maintains a session connection with the user terminal before obtaining the calculation result; After the service node obtains the calculation result of the calculation node, it blocks the session connection with the corresponding user terminal. Accordingly, since the service node continues to maintain the association between the service node and the user terminal before obtaining the calculation result, it is easy to feed back the calculation result to the user terminal.

Through the above manner, the service node obtains a user code for indicating the user terminal; placing the user code in the work queue as a working job, so that the working job is obtained and calculated from the work queue by the computation node; A calculation result of the calculation node is obtained, and the calculation result is fed back to the user terminal to implement the operation of the user code. The service node is used for connection with the user terminal, and the user code sent by the user terminal is placed in the work queue as a working job, so that the computation node independent of the service node obtains the working job from the work queue and calculates the calculation result After obtaining , the service node obtains the calculation result of the calculation node, and feeds back the calculation result to the user terminal, thereby implementing the operation of the user code.

The present application further provides a computation node, which can likewise execute a user code operating method of a programming platform. Referring to FIG. 3 , FIG. 3 is an exemplary flow diagram of another implementation of a user code operation method of a programming platform provided in an embodiment of the present application. Specifically, the embodiment method of the present application includes the following steps.

In step S301, the job queue is monitored to obtain a working job.

Executing the user code operating method of the programming platform in an embodiment of the present application is a computing node in any one embodiment of the user code operating method of the programming platform. The work queue contains operational tasks, and the operational tasks correspond to user codes.

The computation node monitors the work queue containing the work tasks, and obtains the work tasks corresponding to the user code one-to-one from the work queues.

The compute node includes a first compute node and a second compute node, wherein the first compute node and the second compute node are located in the CPU server and the GPU server, respectively, so that the first compute node performs computation in the CPU server in the work queue. and monitoring an operational task dependent on the internal memory resource, and the second computation node monitors the computation in the GPU server in the work queue and the operational task dependent on the internal memory resource. Specifically, the work queue may include a first work queue and a second work queue, and the first computation node and the second computation node respectively monitor the first work queue and the second work queue to obtain a work task. .

That is, the user code corresponds to the work queue, and when the computation node in the embodiment of the present application is the first computation node, obtain the computational and internal memory resource operation tasks in the CPU server from the first work queue; When the computation node is the second computation node, the computational and internal memory resource operation tasks in the GPU server are acquired from the second task queue.

In step S302, an operation operation is calculated, and a calculation result is obtained.

The computation node calculates the operation task by using the computation and internal memory resources in the server to which it belongs, and obtains the computation result. After the compute node completes the calculation of the working task, it releases the corresponding computational resource and continues to monitor the work queue, that is, the compute node releases the resource as soon as it completes the calculation of the current working task, and continues the work queue. By monitoring, it acquires new operational tasks, so that the compute node maximizes multiplexing of computational and internal memory resources.

Through the above manner, monitoring the work queue to obtain a working job; the work queue includes operational tasks, the operational tasks corresponding to user codes; Calculating the operation task to obtain the calculation result, it is implemented that the operation task acquisition of the computation node is sequentially performed. Since the work queue contains an operational task, and the operational task corresponds to the user code, the computation node monitors the task queue containing the operational task to obtain the operational task corresponding to the user code, thereby calculating the operational task and calculating the result. , which implements the acquisition and calculation of the operation task.

The present application further provides a programming platform, and as shown in FIG. 4 , FIG. 4 is an exemplary structural diagram of the programming platform provided in an embodiment of the present application. Specifically, in the embodiment of the present application, the programming platform 40 includes a service node 41 , a work queue 42 , and a computation node 43 . the service node 41 is for obtaining a user code for representing the user terminal, and placing the user code in the work queue 42 as an operation task; The computation node 43 is for monitoring the work queue 42 to obtain a work task; The calculation node 43 is also for calculating an operation task, to obtain a calculation result; The service node 41 is also to obtain a calculation result from the calculation node 43, and feed back the calculation result to the user terminal.

In the embodiment of the present application, the number of computation nodes 43 is at least two; When the computing node 43 monitors the work queue 42 to obtain a working job, at least two computing nodes 43 monitor the job queue 42 and add the working job to the job queue 42 . to request to obtain; The work queue 42 is for assigning working tasks to the computation nodes 43 .

In the embodiment of the present application, the work queue 42 includes a first work queue and a second work queue, and the at least two computation nodes 43 include a first computation node and a second computation node; When the service node 41 is for placing the user code in the work queue 42 as an actuation job, further, according to the computational characteristics of the user code, the user code is placed in the first work queue or the second work queue as the actuating work. for placement; The compute node 43 is for monitoring the work queue 42 , specifically, the first compute node monitors the first work queue, and the second compute node monitors the second work queue.

In the embodiment of the present application, the number of service nodes 41 is at least two; When the service node 41 is to obtain a user code for representing a user terminal, at least two service nodes 41 are assigned a user code by a reverse proxy.

In the embodiment of the present application, the computation node 43 is also to release the corresponding computational resource after completing the computation of the working task and continue to monitor the task queue 42 .

In an embodiment of the present application, the programming platform 40 further includes a message queue 44; When the service node 41 is to obtain the calculation result from the calculation node 43 and feed back the calculation result to the user terminal, the calculation node 43 is also to place the calculation result in the message queue 44 ; The service node 41 is also for monitoring the message queue 42 to obtain a calculation result, and feed back the calculation result to the user terminal.

In the embodiment of the present application, the service node 41 is also for obtaining a 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 for executing the user code operating method of the programming platform. Specifically, as shown in Fig. 5, Fig. 5 is an exemplary structural diagram of an embodiment of the programming platform service node 41 of the present application. The service node 41 includes a receiving unit 411 , a placing unit 412 , and an obtaining unit 413 . Here, the receiving unit 411 is for obtaining a user code for indicating the user terminal; the placing unit 412 is for placing the user code in the work queue as an actuation task, so that the actuation task is obtained and calculated from the work queue by the computation node; The obtaining unit 413 is for obtaining the calculation result of the calculation node, and feeding back the calculation result to the user terminal.

In the embodiment of the present application, when the disposing unit 412 places the user code in the work queue as an actuation task, so that the actuation task is obtained and calculated from the work queue by the computation node, also the computation feature of the user code , placing the user code in the first work queue or the second work queue as the actuation task, so that the actuation task is obtained and calculated from the first work queue by the first computation node, or the second task is obtained by the second computation node It is for the operation task to be obtained and counted from the queue.

In the embodiment of the present application, when the receiving unit 411 is to obtain a user code for indicating the user terminal, the user code is assigned by the reverse proxy.

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

The compute node 43 of the programming platform 40 in FIG. 4 is also for executing a method of operating user code of the programming platform. Specifically, as shown in FIG. 6 , FIG. 6 is a structural diagram of an embodiment of the computation node 43 of the programming platform of the present application. The calculation node 43 includes a monitoring unit 431 and a calculation unit 432 , and the monitoring unit 431 is for monitoring the work queue to obtain a working job, where the working queue includes the working job and the operation operation corresponds to the user code; The calculation unit 432 is for calculating the operation operation to obtain a calculation result.

In the embodiment of the present application, the calculation unit 432 is configured to allow the calculation node 43 to release the corresponding computing resource and continue to monitor the job queue after completing the calculation of the working job.

In order to further describe the programming platform of the present application, referring to FIG. 7 , FIG. 7 is another structural diagram of the programming platform provided in an embodiment of the present application.

In the embodiment of the present application, the programming platform 70 includes a service node 71 , a work queue 72 , a compute node 73 and a message queue 74 , and the work queue 72 includes a first work queue ( 721 ) and a second work queue 722 , wherein the compute node 73 includes a first compute node 731 and a second compute node 732 , and the first compute node 731 comprises a CPU server ( 701 , and the second compute node 732 is located on the GPU server 702 .

When specifically applied, the service node 71 may receive the user code of any one user terminal among the plurality of user terminals, and may simultaneously receive the user codes of the plurality of user terminals, so that the user for indicating the user terminal implement obtaining code; The service node 71 performs a websocket connection with the user terminal, that is, the service node 71 obtains the user code of the user terminal through the websocket communication method. When the user code is placed in the work queue 72 as a working job, according to the calculation characteristics of the user code, it is determined that the user code belongs to the first work queue 721 and the code working resource of the CPU server 701 is used. Thus, the user code is placed in the first work queue 721 as a working job, and the first calculation node 731 monitors the first work queue 721 to obtain and calculate the working job to obtain a calculation result, ; Or, according to the calculation characteristics of the user code, determine that the user code belongs to the second work queue 722 and use the code actuation resource of the GPU server 702 to set the user code as the actuation work to the second work queue ( 722 , wherein the second calculation node 732 monitors the second work queue 722 to obtain and calculate an operation job to obtain a calculation result; The first calculation node 731 and the second calculation 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, and calculate The result is fed back to the corresponding user terminal. The descriptions associated with the service node 71 , the work queue 72 , the compute node 73 and the message queue 74 in the embodiments of the present application may refer to one embodiment of the above programming platform, which is no longer repeated here. do not explain

Through the above manner, the service node places the received user code as a working job in different job queues, respectively; Then, the computation nodes in different servers monitor different work queues, respectively, to obtain the corresponding operational tasks, so that the operational tasks are calculated using different computation and storage resources to obtain the computation results, and the computation nodes send the computation results in a message. placed in queues; Finally, the service node obtains the calculation result of the calculation node from the message queue, and feeds back the calculation result to the user terminal. During the operation of the entire user code, the service node is installed separately from the calculation node, 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 the calculation resources of the calculation node are constantly being used repeatedly. and different computation nodes correspond to different message queues, thereby obtaining and calculating user code dependent on different computation and storage resources, thereby implementing asynchronous communication operated by user code, and improving the parallelism capability of the system.

In an embodiment of the present application, 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 a school or educational institution, etc., and the user terminal is a student terminal accessing the online programming education platform, and implements the operation of the user code. The online programming education platform includes a service node, a work queue and a compute node, where the work queue is a redis list. The student inputs the user code through the programming interface of the student terminal, the service node can receive the user code of the student terminal, and the user code of a plurality of student terminals can be received simultaneously, implement receiving the user code sent by; The service node places user code in the redis list of work queues as working tasks. The compute node monitors the redis list to obtain operational tasks; Calculating the operation task, and obtaining the calculation result. The service node obtains the calculation result from the calculation node, and feeds the calculation result back to the student terminal.

In an 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 work queue, a computation node and a message queue, wherein the work queue includes a redis list including a first work queue and a second work queue; the computation node includes a first computation node and a second computation node; The message queue is RabbitMQ. The service node of the online programming education platform determines, according to the computational characteristics of the user code, that the user code belongs to the first work queue, and uses the code actuation resource of the CPU server to put the user code into the first work queue as an actuation work. Deploy, wherein the first calculation node monitors the first work queue to obtain and calculate the working work to obtain the calculation result; or, the service node determines, according to the computational characteristics of the user code, that the user code belongs to the second work queue, and uses the code actuation resource of the GPU server to place the user code in the second work queue as an actuation work; the second computation node monitors the second work queue to obtain and calculate the work tasks to obtain a computation result; The first calculation node and the second calculation node place the calculation result in the message queue RabbitMQ, and the service node monitors the RabbitMQ, obtains the calculation result, and feeds the calculation result back to the corresponding student terminal.

Through the above method, oriented to schools or educational institutions, etc., the online programming education platform can satisfy more students to simultaneously perform online programming learning on the online programming education platform, so it is realized that the computational resources are fully utilized, and the cost to save

Referring to FIG. 8 , FIG. 8 is an architectural diagram of an embodiment of the electronic device of the present application. Specifically, in the embodiment of the present application, the electronic device 800 includes a memory 810 and a processor 820 coupled to each other. Here, the memory 810 is for storing program instructions and data to be stored when the processor 820 processes it.

Processor 820 controls memory 810 and itself to implement the steps of any one embodiment of the method of operating user code of the programming platform. The processor 820 may also be referred to as a central processing unit (CPU). The processor 820 may be an integrated circuit chip having signal processing capability. The processor 820 may also be a general purpose processor, digital signal processor (DSP), application specific integrated circuit (ASIC), field programmable gate array (FPGA), or other programmable logic device. , a discrete gate or transistor logic device, or a discrete hardware component. A general purpose processor may be a microprocessor or any general processor or the like. In addition, the processor 820 may be jointly implemented by a plurality of integrated circuit chips.

Referring to FIG. 9 , FIG. 9 is an architectural diagram of an embodiment of the storage device of the present application. The storage device 900 of the present application stores a program instruction 901 operable by a processor, and the program instruction 901 is for implementing the steps of the embodiment of the user code operation method of the one programming platform.

The storage device 900 is specifically a U disk, a mobile hard disk, a read-only memory (Read-Only Memory, ROM), a random access memory (Random Access Memory, RAM), a magnetic disk or an optical disk, such as program instructions 901 may be a storage medium (including a volatile storage medium or a non-volatile storage medium), or a server in which the program instructions 901 are stored, and the server operates by transmitting the stored program instructions 901 to other devices. or may operate the stored program instructions 901 .

In the several embodiments provided in this application, it should be understood that the disclosed methods and apparatus may be implemented in other ways. For example, the above-described device embodiment is merely exemplary, for example, division for a module or unit is only logical function division, and when actually implemented, there may be other division manners, for example, a plurality of units Or components may be combined or integrated into other systems, or some features may be ignored or not implemented. Further, any coupling or direct coupling or communication connection between each other shown or discussed may be implemented via some interface, and the indirect coupling or communication connection through a device or unit may be electrical, mechanical, or other form.

A unit described as a separate member may or may not be physically separated, and a member shown as a unit may or may not be a physical unit, that is, may be located in one place or may be distributed in a plurality of network units. Some or all of the units may be selected according to actual needs to implement the purpose of the present embodiment solution.

In addition, each functional unit in each embodiment of the present application may be integrated into one processing unit, each unit may be an independent physical entity, and two or two or more units may be integrated into one unit. . The integrated unit may be implemented using a form of hardware or may be implemented using a form of a software functional unit.

When the integrated unit is implemented in the form of a software functional unit and sold or used as an independent product, it may be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present application, that is, the part contributing to the prior art or all or part of the technical solution may be implemented in the form of a software product, the computer software product being stored in one storage medium, , including a plurality of instructions used to cause one computer device (which may be a personal computer, a server or a network device, etc.) or a processor to execute all or some steps of the method of each embodiment of the present application. The above-described storage medium includes various media capable of storing a program code, such as a U disk, a removable hard disk, a read-only memory (ROM), a random access memory (RAM), a magnetic disk or an optical disk.

This application discloses a method and platform, node, device, medium for operating user code of a programming platform. Here, the programming platform includes a service node, a work queue, and a computation node; A user code activation method of a programming platform includes: a service node obtaining a user code for representing a user terminal, and placing the user code as an activation task in a work queue; the computing node monitoring the work queue to obtain working work; calculating, by the computation node, an operation task to obtain a computation result; and obtaining, by the service node, a calculation result from the calculation node, and feeding back the calculation result to the user terminal.

Claims (28)

A method of operating user code in a programming platform, comprising:
The programming platform includes a service node, a work queue, and a computation node; The method is
obtaining, by the service node, a user code for indicating a user terminal, and placing the user code in the work queue as a working task;
monitoring, by the computation node, the work queue to obtain the working work;
calculating, by the computation node, the operation task to obtain a computation result; and
and the service node obtaining the calculation result from the calculation node, and feeding back the calculation result to the user terminal. According to claim 1,
the number of computation nodes is at least two; The step of the computation node monitoring the work queue to obtain the working task comprises:
monitoring the work queue by at least two of the computation nodes, and requesting the work queue to acquire the working work; and
and the work queue partitioning one of the actuation tasks to the compute nodes. According to claim 1,
the work queue includes a first work queue and a second work queue, and at least two of the computation nodes include a first computation node and a second computation node;
Placing the user code into a work queue as an operational task comprises:
placing the user code in a first work queue or a second work queue as an operational task according to a computational characteristic of the user code;
The step of the computation node monitoring the work queue,
and wherein the first compute node monitors the first work queue and the second compute node monitors the second work queue. 3. The method of claim 1 or 2,
the number of service nodes is at least two; The service node obtaining a user code for indicating a user terminal comprises:
at least two of the service nodes are assigned the user code by a reverse proxy. 5. The method according to any one of claims 1 to 4,
and the computation node, after completing the computation of the working task, releases a corresponding computational resource and continues to monitor the task queue. 6. The method according to any one of claims 1 to 5,
the programming platform further comprises a message queue; obtaining, by the service node, the calculation result from the calculation node, and feeding back the calculation result to the user terminal,
placing, by the computation node, the computation result in the message queue; and
and the service node monitoring the message queue, obtaining the calculation result, and feeding back the calculation result to the user terminal. 7. The method of claim 6,
and the service node maintains a session connection with the user terminal before obtaining the calculation result. A method of operating user code in a programming platform, comprising:
obtaining a user code for indicating a user terminal;
placing the user code in a work queue as a working job, so that the working job is obtained and calculated from the work queue by a computation node; and
and obtaining a calculation result of the calculation node, and feeding back the calculation result to the user terminal. 9. The method of claim 8,
placing the user code in a work queue as a working task, whereby the working task is obtained and calculated from the work queue by a computation node,
according to the calculation feature of the user code, placing the user code as a working task in a first work queue or a second work queue, so that the working task is obtained and calculated from the first work queue by the first computation node; and obtaining and calculating the actuation task from the second work queue by a second computation node. 10. The method according to claim 8 or 9,
Obtaining a user code for indicating the user terminal comprises:
and assigning said user code via a reverse proxy. 11. The method according to any one of claims 8 to 10,
The method of operating user code of the programming platform, comprising maintaining a session connection with the user terminal before obtaining the calculation result. A method of operating user code in a programming platform, comprising:
monitoring a work queue to obtain a working job, wherein the working queue includes the working job, the working job corresponding to the user code; and
and calculating the actuation task to obtain a calculation result. 13. The method of claim 12,
The method of operating user code of the programming platform, comprising the steps of: after completing the calculation for the working task, releasing a corresponding computational resource and continuously monitoring the work queue; . As a programming platform,
the programming platform includes a service node, a work queue, and a computation node;
the service node is configured to obtain a user code for indicating a user terminal, and place the user code as an operation task in the work queue;
the computing node is configured to monitor the work queue to obtain the working work;
the calculation node is also configured to calculate the operation task to obtain a calculation result;
The service node is further configured to obtain the calculation result from the calculation node, and feed back the calculation result to the user terminal. 16. The method of claim 14 or 15,
the number of computation nodes is at least two; when the computing node is configured to monitor the work queue and obtain the working job, at least two of the computing nodes are configured to monitor the work queue and request the work queue to acquire the working job; and the work queue is configured to assign the working work to the compute node. 16. The method of claim 15,
the work queue includes a first work queue and a second work queue, and at least two of the computation nodes include a first computation node and a second computation node;
When the service node is configured to place the user code as a working job in a work queue, specifically, the service node sets the user code as a working job to a first job queue or a second job queue, according to a calculation characteristic of the user code. configured for placement in a work queue; the compute node is configured to monitor the work queue, specifically, the first compute node is configured to monitor the first work queue, and the second compute node is configured to monitor the second work queue. programming platform with 15. The method of claim 14,
the number of service nodes is at least two; and when the service node is configured to obtain a user code for representing a user terminal, at least two of the service nodes are configured to be assigned the user code by a reverse proxy. 18. The method according to any one of claims 14 to 17,
and the computation node is configured to, after completing the computation of the working task, release a corresponding computational resource and continue to monitor the task queue. 19. The method according to any one of claims 14 to 18,
the programming platform further comprises a message queue; when the service node is configured to obtain the calculation result from the calculation node and feed back the calculation result to the user terminal, the calculation node is configured to place the calculation result in the message queue; and the service node is configured to monitor the message queue, obtain the calculation result, and feed back the calculation result to the user terminal. 20. The method of claim 19,
and the service node is configured to maintain a session connection with the user terminal before acquiring the calculation result. As a service node,
a receiving unit, a disposing unit and an obtaining unit, wherein the receiving unit is configured to obtain a user code for indicating the user terminal; the placing unit is configured to place the user code as a working job in a work queue, so that the working job is obtained and calculated from the work queue by a computing node; and the acquiring unit is configured to acquire the calculation result of the calculation node, and feed back the calculation result to the user terminal. 22. The method of claim 21,
when the placing unit is configured to place the user code as an operational task in a work queue, so that the operational task is obtained and calculated from the work queue by a computation node, the placing unit is also configured to: , placing the user code in a first work queue or a second work queue as an actuation task, so that the actuation task is obtained and calculated from the first work queue by a first computation node, or by a second computation node 2 The programming platform of claim 2, wherein the working job is obtained from a job queue and configured to be calculated. 23. The method of claim 21 or 22,
and when the receiving unit is configured to obtain a user code for indicating a user terminal, the receiving unit is also configured to assign the user code through a reverse proxy. 24. The method according to any one of claims 21 to 23,
before the acquiring unit acquires the calculation result, the service node is configured to maintain a session connection with the user terminal. As a compute node,
a monitoring unit and a calculation unit, wherein the monitoring unit is configured to monitor the work queue to obtain an operation task; the job queue includes the working job, the working job corresponding to the user code; and the calculation unit is configured to calculate the operation task to obtain a calculation result. 26. The method of claim 25,
and the computing unit is configured to, after completing the calculation of the working task, also release a corresponding computational resource and continue to monitor the task queue. As an electronic device,
a memory and a processor coupled to each other;
The processor executes the program instructions stored in the memory, the method of operating a user code of the programming platform according to any one of claims 1 to 7; 12. A method of operating user code of a programming platform according to any one of claims 8 to 11; and an electronic device for implementing any one of a method of operating a user code of a programming platform according to claim 12 or claim 13 . A computer-readable storage medium comprising:
a method for operating a user code of a programming platform according to claim 1 ; 12. A method of operating user code of a programming platform according to any one of claims 8 to 11; and a computer program capable of implementing any one of the method of operating a user code of a programming platform according to claim 12 or 13, wherein the computer program is stored.

Images