Method and system for processing test tasks

Abstract

The present invention discloses a method and system for processing a test task. The method comprises: receiving a test task request from a client, wherein the information carried in the test task request comprises: a test task instruction; parsing the test task instruction to generate a plurality of distributed tasks to be executed; scheduling some or all execution nodes in a target distributed cluster to process the plurality of distributed tasks in parallel to obtain a test result. The present invention solves the technical problem that the processing method for solving solver testing using a single machine serial method in the related art has a low test efficiency.

Description

Technical Field

[0001] The present invention relates to the field of computer technology, and in particular to a method and system for processing a test task. Background Art

[0002] In the process of solver optimization, it is necessary to solve a large number of models after each algorithm improvement to test whether the algorithm improvement meets expectations. The execution method of the test in related technologies is usually single-machine serial. However, this method can only test a small number of models. When the number of test models is large, the corresponding test time is long, and the efficiency of solver development and testing is low.

[0003] Therefore, there is no effective solution on how to optimize the processing method of test tasks to improve test efficiency. Summary of the invention

[0004] The embodiment of the present invention provides a method and system for processing a test task, so as to at least solve the technical problem that the processing method of the related art using a single machine serial mode to perform solver testing has low test efficiency.

[0005] According to one aspect of an embodiment of the present invention, a method for processing a test task is provided, comprising: receiving a test task request from a client, wherein the information carried in the test task request includes: a test task instruction; parsing the test task instruction to generate a plurality of distributed tasks to be executed; scheduling some or all execution nodes in a target distributed cluster to process the plurality of distributed tasks in parallel to obtain a test result.

[0006] According to another aspect of an embodiment of the present invention, a method for processing a test task is also provided, including: receiving a cloud computing test task request from a client, wherein the information carried in the cloud computing test task request includes: cloud computing test task instructions; parsing the cloud computing test task instructions to generate multiple distributed cloud computing tasks to be executed; scheduling some or all execution nodes in the target distributed cluster to process multiple distributed cloud computing tasks in parallel to obtain cloud computing test results.

[0007] According to another aspect of an embodiment of the present invention, a method for processing a test task is also provided, including: receiving an electric energy test task request from a client, wherein the information carried in the electric energy test task request includes: an electric energy test task instruction; parsing the electric energy test task instruction to generate a plurality of distributed electric energy tasks to be executed; scheduling some or all execution nodes in the target distributed cluster to process the plurality of distributed electric energy tasks in parallel to obtain an electric energy test result.

[0008] According to another aspect of an embodiment of the present invention, a computer-readable storage medium is also provided, wherein the computer-readable storage medium includes a stored program, wherein when the program is running, the device where the computer-readable storage medium is located is controlled to perform any one of the above-mentioned methods for processing test tasks.

[0009] According to another aspect of an embodiment of the present invention, a processor is further provided, and the processor is used to run a program, wherein the program executes any one of the above-mentioned methods for processing a test task when running.

[0010] According to another aspect of an embodiment of the present invention, a system for processing test tasks is also provided, including: a processor; and a memory, connected to the above-mentioned processor, for providing the above-mentioned processor with instructions for processing the following processing steps: receiving a test task request from a client, wherein the information carried in the test task request includes: test task instructions; parsing the test task instructions to generate multiple distributed tasks to be executed; scheduling some or all execution nodes in the target distributed cluster to process multiple distributed tasks in parallel to obtain test results.

[0011] In an embodiment of the present invention, a test task request is first received from a client, wherein the information carried in the test task request includes: test task instructions, and multiple distributed tasks to be executed are generated by parsing the test task instructions. A method of scheduling some or all execution nodes in a target distributed cluster to process multiple distributed tasks in parallel is adopted to obtain a test result.

[0012] It is easy to notice that, through the embodiments of the present application, analysis is performed based on the test task request issued by the client, and then the test is executed and the test results are obtained through the scheduling operation, thereby achieving the purpose of realizing multi-machine parallelism in the optimization solver test through the analysis operation and the scheduling operation, thereby achieving the technical effect of reducing the optimization solver test time and improving the optimization solver test efficiency, and thus solving the technical problem of low test efficiency of the related technology processing method of using a single-machine serial method to perform solver testing. BRIEF DESCRIPTION OF THE DRAWINGS

[0013] The drawings described herein are used to provide a further understanding of the present invention and constitute a part of this application. The exemplary embodiments of the present invention and their descriptions are used to explain the present invention and do not constitute an improper limitation of the present invention. In the drawings:

[0014] Figure 1 A hardware structure block diagram of a computer terminal (or mobile device) for implementing a method for processing a test task is shown;

[0015] Figure 2 is a flow chart of a method for processing a test task according to an embodiment of the present invention;

[0016] Figure 3 is a schematic diagram of an optional solver parallel test initiation process according to an embodiment of the present invention;

[0017] Figure 4 is a schematic diagram of an optional process of a node executing a distributed task according to an embodiment of the present invention;

[0018] Figure 5 is a flowchart of another method for processing a test task according to an embodiment of the present invention;

[0019] Figure 6 is a flowchart of another method for processing a test task according to an embodiment of the present invention;

[0020] Figure 7 is a structural schematic diagram of a device for processing a test task according to an embodiment of the present invention;

[0021] Figure 8 is a schematic structural diagram of another device for processing a test task according to an embodiment of the present invention;

[0022] Fig. 9 is a structural schematic diagram of another device for processing a test task according to an embodiment of the present invention;

[0023] Fig.10 is a structural schematic diagram of another device for processing a test task according to an embodiment of the present invention;

[0024] Fig.11 is a structural schematic diagram of another device for processing a test task according to an embodiment of the present invention;

[0025] Fig.12 is a structural block diagram of another computer terminal according to an embodiment of the present invention. DETAILED DESCRIPTION

[0026] In order to enable those skilled in the art to better understand the scheme of the present invention, the technical scheme in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work should fall within the scope of protection of the present invention.

[0027] It should be noted that the terms "first", "second", etc. in the specification and claims of the present invention and the above-mentioned drawings are used to distinguish similar objects, and are not necessarily used to describe a specific order or sequence. It should be understood that the data used in this way can be interchanged where appropriate, so that the embodiments of the present invention described herein can be implemented in an order other than those illustrated or described herein. In addition, the terms "including" and "having" and any variations thereof are intended to cover non-exclusive inclusions, for example, a process, method, system, product or device that includes a series of steps or units is not necessarily limited to those steps or units that are clearly listed, but may include other steps or units that are not clearly listed or inherent to these processes, methods, products or devices.

[0028] First, some nouns or terms that appear in the description of the embodiments of the present application are subject to the following explanations:

[0029] Parallel computing: refers to the process of using multiple computing resources simultaneously to solve computing problems. It is an effective means to improve the computing speed and processing power of computer systems.

[0030] Optimization solver: refers to software for solving optimization problems. For example: MindOpt, Gurobi, CPLEX, etc.

[0031] Key Value (KV) memory storage: refers to a form of memory data storage that can be used as a database, cache, or message channel, such as Redis.

[0032] Relational database: refers to a database that uses a relational model to organize data. Relational databases store data in the form of rows and columns for easy understanding by users. A series of rows and columns in a relational database constitutes a table, and a group of tables constitutes a database. For example, MySQL.

[0033] Object file storage: refers to a massive, secure, low-cost, and highly reliable cloud storage service suitable for storing any type of files. For example, Object Storage Service (OSS).

[0034] Container technology: refers to the technology of packaging or isolating an application and its entire operating environment (including all required files). Containers are special programs used for packaging or isolation in container technology, which can limit their own CPU resources and memory resources. Applications can run in containers. For example, Docker.

[0035] Example 1

[0036] According to an embodiment of the present invention, a method embodiment for processing a test task is also provided. It should be noted that the steps shown in the flowchart of the accompanying drawings can be executed in a computer system such as a set of computer executable instructions, and although a logical order is shown in the flowchart, in some cases, the steps shown or described can be executed in an order different from that shown here.

[0037] The method embodiment provided in the first embodiment of the present application can be executed in a mobile terminal, a computer terminal or a similar computing device. Figure 1 The hardware structure block diagram of a computer terminal (or mobile device) for implementing the method for processing a test task is shown. Figure 1 As shown, the computer terminal 10 (or mobile device 10) may include one or more (102a, 102b, ..., 102n are used to illustrate) processors 102 (the processor 102 may include but is not limited to a processing device such as a microprocessor MCU or a programmable logic device FPGA), a memory 104 for storing data, and a transmission device 106 for communication functions. In addition, it may also include: a display, an input / output interface (I / O interface), a universal serial bus (USB) port (which may be included as one of the ports of the BUS bus), a network interface, a power supply and / or a camera. It can be understood by those skilled in the art that Figure 1 The structure shown is only for illustration and does not limit the structure of the above electronic device. Figure 1 More or fewer components as shown, or with Figure 1 Different configurations are shown.

[0038] It should be noted that the one or more processors 102 and / or other data processing circuits described above may generally be referred to herein as "data processing circuits". The data processing circuits may be embodied in whole or in part as software, hardware, firmware, or any other combination thereof. In addition, the data processing circuit may be a single independent processing module, or may be incorporated in whole or in part into any of the other components in the computer terminal 10 (or mobile device). As described in the embodiments of the present application, the data processing circuit acts as a processor control (e.g., selection of a variable resistor terminal path connected to an interface).

[0039] The memory 104 can be used to store software programs and modules of application software, such as program instructions / data storage devices corresponding to the method for processing test tasks in the embodiment of the present invention. The processor 102 executes various functional applications and data processing by running the software programs and modules stored in the memory 104, that is, realizing the above-mentioned method for processing test tasks. The memory 104 may include a high-speed random access memory, and may also include a non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some examples, the memory 104 may further include a memory remotely arranged relative to the processor 102, and these remote memories may be connected to the computer terminal 10 via a network. Examples of the above-mentioned network include, but are not limited to, the Internet, an intranet, a local area network, a mobile communication network, and combinations thereof.

[0040] The transmission device 106 is used to receive or send data via a network. The specific example of the above network may include a wireless network provided by a communication provider of the computer terminal 10. In one example, the transmission device 106 includes a network adapter (Network Interface Controller, NIC), which can be connected to other network devices through a base station so as to communicate with the Internet. In one example, the transmission device 106 can be a radio frequency (RF) module, which is used to communicate with the Internet wirelessly.

[0041] The display may be, for example, a touch screen liquid crystal display (LCD) that enables a user to interact with a user interface of the computer terminal 10 (or mobile device).

[0042] It should be noted that, in some optional embodiments, the above Figure 1 The computer device (or mobile device) shown may include hardware elements (including circuits), software elements (including computer code stored on a computer-readable medium), or a combination of hardware elements and software elements. It should be noted that Figure 1 This is merely one example of a particular embodiment and is intended to illustrate the types of components that may be present in the above-described computer device (or mobile device).

[0043] Under the above operating environment, this application provides Figure 2 A method of handling test tasks is shown. Figure 2 is a flow chart of a method for processing a test task according to an embodiment of the present invention. Figure 2 As shown, the method for processing the test task includes:

[0044] Step S202, receiving a test task request from a client, wherein the information carried in the test task request includes: a test task instruction;

[0045] Step S204, parsing the test task instruction to generate a plurality of distributed tasks to be executed;

[0046] Step S206, scheduling some or all execution nodes in the target distributed cluster to process multiple distributed tasks in parallel to obtain test results.

[0047] In the above optional embodiment, the test task request may be a request message issued by the client based on the test task, and the test task may be a task corresponding to a certain test of the optimization solver. The information carried in the test task request may include a test task instruction, and the test task instruction may be a computer executable instruction corresponding to the test task.

[0048] In the above optional embodiment, the test task instruction is parsed to generate multiple distributed tasks to be executed. The multiple distributed tasks can be processed in parallel. The above target distributed cluster can be a computer cluster for executing the above test task, and the computer cluster can include multiple execution nodes. The execution node can be a physical machine for calculation. By scheduling some or all of the execution nodes in the target distributed cluster, the multiple distributed tasks can be processed in parallel, and then the above test results can be obtained.

[0049] It is easy to notice that in the above optional embodiment, multiple distributed tasks are obtained by parsing the test task instruction. The multiple distributed tasks correspond to the test tasks and can be processed in parallel. Through the above method for processing test tasks, when the number of optimization solver test models is large, multi-machine parallel computing can be achieved, which greatly reduces the test time and improves the test efficiency compared with the single-machine serial computing in the related art.

[0050] It should be noted that the above method for processing test tasks can be run on the server side to receive and respond to test task requests issued by the client. In actual application scenarios, the server side can correspond to multiple clients and use its powerful computing performance to solve test task requests issued by multiple clients, thereby greatly improving the solver development efficiency and testing efficiency.

[0051] In an embodiment of the present invention, a test task request is first received from a client, wherein the information carried in the test task request includes: test task instructions, and multiple distributed tasks to be executed are generated by parsing the test task instructions. A method of scheduling some or all execution nodes in a target distributed cluster to process multiple distributed tasks in parallel is adopted to obtain a test result.

[0052] It is easy to notice that, through the embodiments of the present application, analysis is performed based on the test task request issued by the client, and then the test is executed and the test results are obtained through the scheduling operation, thereby achieving the purpose of realizing multi-machine parallelism in the optimization solver test through the analysis operation and the scheduling operation, thereby achieving the technical effect of reducing the optimization solver test time and improving the optimization solver test efficiency, and thus solving the technical problem of low test efficiency of the related technology processing method of using a single-machine serial method to perform solver testing.

[0053] It should be noted that the embodiments of the present invention can be applicable to, but not limited to, optimization solver development application scenarios and optimization solver testing application scenarios. For example, it can also be applied to the following technical fields of application optimization solvers: electric power energy field (such as energy technology, energy management, energy generation, energy equipment, power transmission, power distribution, power measurement, etc.); industrial manufacturing field (such as agricultural and sideline food processing, food manufacturing, tobacco products, textiles, mechanical and electronic manufacturing, etc.); transportation and logistics field (such as railway transportation, road transportation, water transportation, air transportation, logistics collection, logistics distribution, etc.); retail field (such as commodity management, sales analysis, etc.); financial field (such as bank management, insurance analysis, securities analysis, etc.); medical field (such as medical data analysis, electronic medical records, appointment registration information management, etc.); education field (such as course data management, learning data analysis, etc.).

[0054] It is easy to notice that, through the method provided in this embodiment, the client can use command line syntax to initiate a batch of test tasks at one time, and the server distributes these test tasks to multiple execution nodes for parallel processing, which can greatly reduce the processing time of the test tasks and improve the efficiency of the optimization solver test.

[0055] In an optional embodiment, in step S204, the test task instruction is parsed to generate multiple distributed tasks, including the following method steps:

[0056] Step S241, parsing the test task instruction to obtain a parsing result, wherein the parsing result includes: first information, second information and third information, the first information is used to determine the program to be executed, the second information is used to determine the execution logic of the program to be executed, and the third information is used to determine the model file to be tested;

[0057] Step S242, based on the first information, the second information and the third information, the test task instruction is expanded into a plurality of sub-commands;

[0058] Step S243, generating multiple distributed tasks using multiple sub-commands.

[0059] In the above optional embodiment, the test task instruction may be information carried in the test task request issued by the client, and the test task instruction may be a computer executable instruction corresponding to the test task. The parsing result obtained by parsing the test task instruction may include: the above first information, the above second information and the above third information. The first information may be a command line tool, which may be used to determine the program to be executed; the second information may be an execution parameter, which may be used to determine the execution logic of the program to be executed; the third information may be a model file to be solved, which may be used to determine the model file to be tested.

[0060] In the optional embodiment, based on the first information, the second information and the third information, the test task instruction can be expanded into the multiple sub-commands, and then the multiple distributed tasks are generated using the multiple sub-commands. The multiple distributed tasks can be processed in parallel.

[0061] Figure 3 is a schematic diagram of an optional solver parallel test initiation process according to an embodiment of the present invention, such as Figure 3 As shown, the user can initiate a test task to the task application programming interface (API) through a web page or a software development kit (SDK). The SDK may include a Python SDK, a Java SDK, or other language SDKs.

[0062] Optionally, when a user initiates a test task, the program to be executed, the model file to be executed, and the execution parameters corresponding to the test task can be specified. The execution program is uploaded to the tool set of the test task processing platform in the form of a compressed package, and the model file to be executed and other related data are uploaded to the file storage space of the test task processing platform. The execution parameters can be directly given by the user when initiating the test task.

[0063] Still like Figure 3 As shown, after the task API receives the test task instruction issued by the client, it performs syntax analysis on the test task instruction to obtain the analysis result. The analysis result includes the following corresponding to the test task: the program to be executed (equivalent to the above-mentioned first information), the model file to be executed (equivalent to the above-mentioned third information) and the execution parameters (equivalent to the above-mentioned second information). The task API can also convert the analysis result into a batch of sub-commands to be executed, and use the sub-commands to be executed to generate multiple distributed tasks.

[0064] For example: when testing an improved optimization solver abc, it is necessary to execute the following test instructions for model file a1, model file a2 and model file a3: . / abc-i 1ax. In this test instruction, "abc" is the command line tool to be executed, "-i 1" is the execution parameter, and "ax" is the model file to be executed. The command line tool can be used to determine the program to be executed. The execution parameter can be used to determine the execution logic of the program to be executed (such as: when the execution parameter is 1, the optimization solver abc will open a web page; when the execution parameter is 2, the optimization solver abc will download a web page).

[0065] Still for example: when testing a certain improved optimization solver abc, the user may initiate a test task which may include the following steps:

[0066] Step 1: Upload the command line tool "abc" to be executed to the tool set of the test task processing platform;

[0067] Step 2: Upload model files a1, a2, and a3 to the " / x / y / " directory in the file storage space of the test task processing platform;

[0068] Step 3: Initiate a distributed test task through the test instruction ". / abc -i 1%DATA: / x / y / ".

[0069] After the client initiates the above test task to the server backend, the task API in the server backend will parse the test task instruction and generate multiple distributed tasks. The server backend can automatically read the model file content under the directory " / x / y / " based on the test instruction ". / abc-i1%DATA: / x / y / ", and then expand the test instruction into the following batch of distributed commands (equivalent to the above multiple distributed tasks): ". / abc-i 1a1", ". / abc-i 1a2", ". / abc-i1a3".

[0070] Specifically, the parsing results obtained by the task API parsing test instruction ". / abc -i 1%DATA: / x / y / " in the server background may include: command line tool "abc" (equivalent to the above-mentioned first information); execution parameter "-i 1" (equivalent to the above-mentioned second information); model file a1, model file a2 and model file a3 (equivalent to the above-mentioned third information).

[0071] It should be noted that the keyword "%DATA:" in the above test instruction can be used to reference a directory or file in the file storage space of the test task processing platform. In addition, in this embodiment, the keyword "%PARAM:SET:" can be provided to specify a batch of custom experimental parameters; in this embodiment, the keyword "%PARAM:SEQ:" can be provided to specify a batch of digital parameters; in this embodiment, the keyword "%PARAM:SAMPLE:" can be provided to specify digital sampling parameters.

[0072] It should be noted that the above-mentioned multiple keywords can be nested during the test process, and the test task processing platform usually expands distributed commands in the form of Cartesian product. For test scenarios that are not expanded by Cartesian products, the keyword "%FILE:" can be used to finely control the list of commands to be executed. The keyword "%FILE:" is used to read the file content in the file storage space of the test task processing platform specified by preset parameters line by line, and can also be used to expand the file content into a set of commands to be executed. In particular, the above-mentioned multiple keywords can be nested in the file content to specify data and preset parameters.

[0073] In an optional embodiment, the method for processing a test task further includes the following method steps:

[0074] Step S208, storing the analysis result in a first storage area, wherein the first storage area stores data in a table format;

[0075] Step S210, in response to a new task query request, when it is determined that the analysis result is queried from the first storage area, the parameter information associated with multiple distributed tasks is stored in the second storage area, wherein the second storage area stores data in the form of memory, and the parameter information includes: first information, second information, third information, fourth information and fifth information, the fourth information is used to determine the task identifiers of multiple distributed tasks, and the fifth information is used to determine the task timeout period of multiple distributed tasks.

[0076] In the above optional embodiment, the analysis result may include the above first information, the above second information and the above third information. The analysis result may be used to generate the above multiple distributed tasks. The above first storage area stores data in a table form. For example, the first storage area may be a relational database MySQL.

[0077] In the above optional embodiment, when a newly added task query request is detected and it is determined that the above parsing result is queried from the above first storage area, the parameter information associated with the above multiple distributed tasks is stored in the above second storage area. The multiple distributed tasks correspond to the test tasks and can be processed in parallel. The parameter information associated with the distributed tasks may include: the above first information, the above second information, the above third information, the above fourth information and the above fifth information. The above second storage area stores data in the form of memory, for example: the second storage area can be KV memory storage.

[0078] In the above optional embodiment, the above first information may be a command line tool, which can be used to determine the program to be executed; the above second information may be an execution parameter, which can be used to determine the execution logic of the program to be executed; the above third information may be a model file to be solved, which can be used to determine the model file to be tested; the above fourth information may be used to determine the task identifiers of the above multiple distributed tasks; the above fifth information may be used to determine the task timeout of the above multiple distributed tasks. The first information, the second information, and the third information may be obtained by interpreting the test task instruction.

[0079] Still like Figure 3 As shown, the task API in the server backend can store the parsing results obtained by parsing the test task instructions in a database (which can be a relational database, such as MySQL).

[0080] Still like Figure 3 As shown, the task API in the server backend can also initiate a real-time triggered new test task check request (equivalent to the above-mentioned new task query request). The new test task check is performed by the task scheduler in the server backend. When the task scheduler queries the parsing result of the test task instruction from the database, the parameter information associated with the above batch of distributed commands is stored in the KV memory storage.

[0081] Still like Figure 3 As shown, the above-mentioned real-time triggered newly added test task check is executed by the task scheduler. The task scheduler can obtain a distributed lock from the key value memory storage and query the status information of each distributed task in multiple distributed tasks based on the data stored in the database.

[0082] In particular, since the check is triggered very frequently in actual application scenarios, a rate limiter can be set in the background of the server. The rate limiter can be used to control the timing triggering of the new test task check. If multiple new test task check requests are triggered within a period of time, only one new test task check will be executed within this period of time. The rate limiter can merge multiple new test task check requests initiated by the task API within this period of time, and transmit the merged new test task check requests to the task scheduler.

[0083] It should be noted that the status information of the test task may include: waiting, scheduling, executing, successful execution, failed execution, etc. When the client submits the test task to the server backend, the server backend will update the test task status information stored in the database from waiting to scheduling. When scheduling tasks, the task scheduler will determine whether to store the parameter information associated with the test task in the KV memory storage based on the status information of the test task in the database, and determine whether to submit the test task to the distributed cluster for execution.

[0084] In an optional embodiment, the method for processing a test task further includes the following method steps:

[0085] Step S212, determining the number of available execution nodes in the target distributed cluster and the computing resources to be used for the multiple distributed tasks;

[0086] Step S214: Select some or all execution nodes from the target distributed cluster based on the number of available execution nodes and the computing resources to be used.

[0087] In the above optional embodiment, the above target distributed cluster may be a computer cluster for executing the above test task, and the computer cluster may include multiple execution nodes. The execution node may be a physical machine for computing. The above available execution node may be a node that is running normally and has not executed a task (e.g., an execution node in a "waiting" state).

[0088] In the above optional embodiment, multiple distributed tasks are obtained by parsing the test task instruction. The multiple distributed tasks correspond to the test task and can be processed in parallel. The above computing resources to be used can be the maximum configuration resources (such as memory resources, CPU resources, etc.) occupied when the multiple distributed tasks are executed simultaneously.

[0089] In the above optional embodiment, the number of available execution nodes in the target distributed cluster and the computing resources to be used for the multiple distributed tasks are determined, and based on the number of available execution nodes and the computing resources to be used, some or all execution nodes can be selected from the target distributed cluster. The some or all execution nodes can be used to process the multiple distributed tasks in parallel.

[0090] Still like Figure 3 As shown, the target distributed cluster can be an external network workgroup or an internal network workgroup. Both the external network workgroup and the internal network workgroup can contain multiple groups, each of which can contain multiple physical machines (such as PCs, ECS servers, etc., which are equivalent to the above nodes). The task scheduler in the server backend can obtain the number of executable nodes in the target distributed cluster. Among them, the executable node is a node that is in an idle state (no test task is executed).

[0091] Still like Figure 3 As shown, the task scheduler can query the execution status of unfinished distributed tasks based on the data stored in the database, so as to determine the maximum configuration occupancy (equivalent to the above-mentioned computing resources to be used) when multiple distributed tasks are executed.

[0092] Still like Figure 3 As shown, the task scheduler can select multiple nodes from the external network workgroup based on the number of executable nodes in the target distributed cluster and the maximum configuration occupancy when multiple distributed tasks are executed. The multiple nodes can be used to process the multiple distributed tasks in parallel.

[0093] It should be noted that when scheduling test tasks, the task scheduler can achieve cluster isolation (such as scheduling some tasks to the same container for execution), maximum occupied node limit, task timeout stop, task interface stop and other effects in the task dimension according to the needs of the actual application scenario.

[0094] In an optional embodiment, in step S206, scheduling some or all execution nodes in the target distributed cluster to process multiple distributed tasks in parallel to obtain a test result includes the following method steps:

[0095] Step S261, obtaining parameter information from the second storage area;

[0096] Step S262, determining the program to be executed, the execution logic of the program to be executed, and the model file to be tested through the parameter information;

[0097] Step S263, based on the execution environment corresponding to each distributed task in the multiple distributed tasks, schedule some or all execution nodes to process the multiple distributed tasks in parallel using the program to be executed, the execution logic of the program to be executed and the model file to be tested to obtain the test results.

[0098] In the above optional embodiment, the above second storage area stores data in the form of memory, for example: the second storage area can be KV memory storage. The parameter information stored in the second storage area includes: the above first information, the above second information, the above third information, the above fourth information and the above fifth information. Among them, the above first information can be used to determine the program to be executed; the above second information can be used to determine the execution logic of the program to be executed; the above third information can be used to determine the model file to be tested; the above fourth information can be used to determine the task identifier of the above multiple distributed tasks; the above fifth information can be used to determine the task timeout of the above multiple distributed tasks. Obtain parameter information from the second storage area, and the program to be executed, the execution logic of the program to be executed and the model file to be tested in the test task can be determined through the parameter information.

[0099] In the above optional embodiment, multiple distributed tasks are obtained by parsing the test task instruction. The multiple distributed tasks correspond to the test tasks and can be processed in parallel. Some or all of the above execution nodes can be execution nodes selected from the target distributed cluster. Based on the execution environment corresponding to each distributed task in the multiple distributed tasks, the part or all of the execution nodes can be scheduled to process the multiple distributed tasks in parallel using the program to be executed, the execution logic of the program to be executed and the model file to be tested, so as to obtain the above test results. The test result can be the parallel processing result of the test task.

[0100] Still like Figure 3 As shown, when an execution node in the target distributed cluster detects a new task scheduled to the execution node in the KV memory storage, the execution node can obtain the task parameter information stored when the task is submitted from the KV memory storage and start executing the task.

[0101] Figure 4 is a schematic diagram of an optional process of a node executing a distributed task according to an embodiment of the present invention, such as Figure 4 As shown, a node in the target distributed cluster may perform a corresponding distributed task by the following method steps:

[0102] Step S2601, obtaining parameter information of the corresponding distributed task from the KV storage;

[0103] Step S2602, updating the task status of the distributed task and the node information executing the distributed task to the server backend;

[0104] Step S2603, clearing the directory of historically executed tasks and preparing the execution directory of the current distributed task;

[0105] Step S2604, downloading the execution toolkit corresponding to the distributed task, and automatically decompressing the downloaded zip format compressed package;

[0106] Step S2605, downloading the execution data that the distributed task depends on, and automatically decompressing the downloaded zip format compressed package;

[0107] Step S2606, determine whether the current distributed task depends on the container environment: if the current distributed task depends on the container environment, start the user test command with the specified container or sandbox. At this time, it is necessary to limit the maximum available resources (such as memory resources, CPU resources, etc.) of the container or sandbox and mount the execution directory of the distributed task to the container or sandbox; if the current distributed task does not depend on the container environment, it means that the execution environment is the Host machine, then start the user test command on the current execution node;

[0108] Step S2607, in the process of starting the user test command, uploading the execution log to the object file storage in real time, and collecting and uploading the specified file after starting the user test command;

[0109] Step S2608, executing the statistical command and uploading the statistical command result;

[0110] Step S2609, update the distributed task status and execution results to the server backend.

[0111] Still like Figure 3 As shown, in the process of executing distributed tasks on the execution node, the local file cache of the execution node will be checked first in all downloading steps. If the required file does not exist, the file will be downloaded from the object file storage.

[0112] It is easy to notice that in the method provided in this embodiment, the execution environment of the execution node can be configured when executing distributed tasks (such as: executing directly on the execution node or executing in a specified container). In addition, in the process of multiple execution nodes processing test tasks in parallel, all parameter information transmission and data transmission are implemented through KV memory storage or object file storage, indicating that there is no direct data interaction between the execution node and the server backend. Therefore, the method provided in this embodiment can support a server backend to simultaneously access multiple machines in different network environments as an execution node cluster.

[0113] In an optional embodiment, the method for processing a test task further includes the following method steps:

[0114] Step S216, storing the first data in the test results in the third storage area, and storing the second data in the test results in the second storage area, wherein the third storage area stores data in the form of files, the first data is unstructured data in the test results, and the second data is structured data in the test results.

[0115] In the above optional embodiment, the above test result may be a parallel processing result of the test task. The test result may include: first data and second data. The first data is unstructured data (referring to binary files, such as files, programs, pictures, etc.), and the second data is structured data (referring to text data, such as strings in JSON format).

[0116] In the above optional embodiment, the above second storage area stores data in the form of memory, for example, the second storage area may be KV memory storage. The above third storage area stores data in the form of files, for example, the third storage area may be object file storage. The above first data in the above test result is stored in the third storage area, and the above second data in the above test result is stored in the second storage area.

[0117] In an optional embodiment, the method for processing a test task further includes the following method steps:

[0118] Step S218, in response to the test result update message, transferring the second data from the second storage area to the first storage area;

[0119] Step S220: query the second data from the first storage area, and feed back the second data to the client.

[0120] In the above optional embodiment, when a test result update message is received, the above second data is transferred from the above second storage area to the above first storage area. Furthermore, the second data can be queried from the first storage area and fed back to the client. The second storage area stores data in the form of memory, and the first storage area stores data in the form of a table. The second data is structured data in the test result (referring to text data, such as a string in JSON format).

[0121] Still like Figure 3 As shown, when all execution nodes in the target distributed cluster have completed execution, the test result corresponding to the test task can be obtained. The unstructured data in the test result is uploaded to the object file storage, and the structured data in the test result is uploaded to the KV memory storage.

[0122] Still like Figure 3As shown, KV memory storage can publish test result update messages and publish structured data in the test results to the message subscription module in the server backend. After receiving the structure update message, the message subscription module can store the latest test results in the database.

[0123] Still like Figure 3 As shown, the server backend can obtain the execution results and execution logs of all test tasks by querying the data stored in the database, and provide a display page and query interface for the test results accordingly.

[0124] It is easy to notice that the beneficial effects of the method for processing test tasks provided in this embodiment are: the command syntax can be parsed in a data-driven manner, and a single-line command can be automatically expanded into a batch of sub-commands, thereby obtaining multiple distributed tasks that support parallel processing; it can also be compatible with execution nodes in different network environments in a distributed cluster; it can also provide a way for SDK to initiate test tasks, supporting users to implement testing of solvers in different languages; it can also support defining the execution environment of test tasks by container, thereby supporting the server-side backend to manage multiple clusters at the same time, supporting users to customize the maximum node occupancy of test tasks and other distributed task scheduling methods, and supporting data file cache acceleration.

[0125] In an optional embodiment, a graphical user interface is provided by a client, and the content displayed by the graphical user interface at least partially includes a test task parallel processing scenario, and the method for processing the test task further includes the following method steps:

[0126] Step S302, receiving the program to be executed and the model file to be tested uploaded on the client through the graphical user interface;

[0127] Step S304, receiving a test task instruction inputted through a graphical user interface on a client, wherein the test task instruction includes: an execution parameter, the execution parameter is used to determine the execution logic of the program to be executed;

[0128] Step S306, scheduling some or all execution nodes to process multiple distributed tasks in parallel using the program to be executed, the execution logic of the program to be executed, and the model file to be tested to obtain a test result;

[0129] Step S308, returning the test result to the client and displaying the test result in a graphical user interface.

[0130] In the above optional embodiment, the graphical user interface content provided by the client may at least partially include the above test task parallel processing scenario. The client may upload the program to be executed and the model file to be tested to the server through the graphical user interface. The client may also input the test task instruction through the graphical user interface. The test task instruction may include execution parameters. The execution parameters may be used to determine the execution logic of the program to be executed.

[0131] In the above optional embodiment, after the server receives the program to be executed and the model file to be tested uploaded by the client through the graphical user interface, and receives the test task instructions input by the client through the graphical user interface, it can schedule some or all of the above execution nodes to use the program to be executed, the execution logic of the program to be executed and the model file to be tested to process the above multiple distributed tasks in parallel, and then obtain the test results.

[0132] In the above optional embodiment, the server can return the obtained test result to the client. The client can display the test result returned by the server to the user through a graphical user interface.

[0133] Optionally, the above-mentioned program to be executed and the model file to be tested can also be obtained by the server by parsing the test task execution. The above-mentioned multiple distributed tasks correspond to the test tasks and can be processed in parallel. Some or all of the above-mentioned execution nodes can be execution nodes selected from the target distributed cluster, and the part or all of the execution nodes can be used to process the multiple distributed tasks in parallel. The above-mentioned test results can be the parallel processing results of the test tasks.

[0134] In an optional embodiment, the method for processing a test task further includes the following method steps:

[0135] Step S310, in the process of parallel processing of multiple distributed tasks, in response to the adjustment operation performed on the client through the graphical user interface, update the to-be-executed program and / or multiple distributed tasks, wherein updating the multiple distributed tasks includes at least one of the following: adding new distributed tasks based on the multiple distributed tasks, terminating the execution of some of the distributed tasks being executed among the multiple distributed tasks.

[0136] In the above optional embodiment, during the process of the server performing parallel processing on the above multiple distributed tasks, the client can perform the above adjustment operation through the above graphical user interface. The adjustment operation can be used to update the program to be executed and / or multiple distributed tasks.

[0137] Optionally, updating multiple distributed tasks may be: adding new distributed tasks based on existing multiple distributed tasks; terminating the execution of some of the distributed tasks that are being executed among the existing multiple distributed tasks; adding new distributed tasks based on the existing multiple distributed tasks, and terminating the execution of some of the distributed tasks that are being executed among the existing multiple distributed tasks.

[0138] Optionally, the above adjustment operation may be to re-upload the program to be executed through the web page or SDK, re-enter the test task instructions, adjust the entered test task instructions, etc.

[0139] It is easy to notice that, through the method provided in this embodiment, the user can make real-time dynamic adjustments in the process of executing the test task on the server side, which improves the flexibility of the solver testing process, thereby improving the efficiency of solver development and testing, and is conducive to application in actual scenarios.

[0140] It is easy to notice that the beneficial effect of the method provided in this embodiment is also to support high-concurrency, distributed solver testing. Specifically, a graphical user interface for processing test tasks is provided to facilitate configuration of algorithms (such as: algorithm main program, algorithm-related data, configuration parameters, etc.), thereby supporting multiple testing methods. For example: configuration parameter tuning under fixed program fixed data, universal parameter tuning under fixed program multiple data, etc.

[0141] Under the above operating environment, the present invention provides Figure 5 A method of handling test tasks is shown. Figure 5 is a flowchart of another method for processing a test task according to an embodiment of the present invention. Figure 5 As shown, the method for processing the test task includes:

[0142] Step S502, receiving a cloud computing test task request from a client, wherein the information carried in the cloud computing test task request includes: a cloud computing test task instruction;

[0143] Step S503, parsing the cloud computing test task instruction to generate a plurality of distributed cloud computing tasks to be executed;

[0144] Step S504: Schedule some or all execution nodes in the target distributed cluster to process multiple distributed cloud computing tasks in parallel to obtain cloud computing test results.

[0145] In the above optional embodiment, the cloud computing test task request may be a request message issued by the client based on the cloud computing test task, and the cloud computing test task may be a task corresponding to a certain test of the cloud computing solver. The information carried in the cloud computing test task request may include a cloud computing test task instruction, and the cloud computing test task instruction may be a computer executable instruction corresponding to the cloud computing test task.

[0146] In the above optional embodiment, the cloud computing test task instruction is parsed to generate multiple distributed cloud computing tasks to be executed. The multiple distributed cloud computing tasks can be processed in parallel. The above target distributed cluster can be a computer cluster for executing the above cloud computing test task, and the computer cluster can include multiple execution nodes. The execution node can be a physical machine for computing. By scheduling some or all of the execution nodes in the target distributed cluster, the multiple distributed cloud computing tasks can be processed in parallel, and then the above cloud computing test results can be obtained.

[0147] It is easy to notice that in the above optional embodiment, multiple distributed cloud computing tasks are obtained by parsing the cloud computing test task instruction. The multiple distributed cloud computing tasks correspond to the cloud computing test tasks and can be processed in parallel. Through the above method for processing cloud computing test tasks, when the number of cloud computing solver test models is large, multi-machine parallel computing can be achieved, which greatly reduces the test time and improves the test efficiency compared with the single-machine serial computing in the related art.

[0148] It should be noted that the above method for processing cloud computing test tasks can be run on the server side to receive and respond to cloud computing test task requests issued by the client. In actual application scenarios, the server side can correspond to multiple clients and use its powerful computing performance to solve cloud computing test task requests issued by multiple clients, thereby greatly improving the efficiency of cloud computing solver development and testing.

[0149] In an embodiment of the present invention, a cloud computing test task request is first received from a client, wherein the information carried in the cloud computing test task request includes: cloud computing test task instructions, by parsing the cloud computing test task instructions, generating multiple distributed cloud computing tasks to be executed, and adopting a method of scheduling some or all execution nodes in the target distributed cluster to parallelly process multiple distributed cloud computing tasks to obtain a cloud computing test result.

[0150] It is easy to notice that, through the embodiments of the present application, parsing is performed based on the cloud computing test task request issued by the client, and then the test is executed and the cloud computing test result is obtained through the scheduling operation, thereby achieving the purpose of realizing multi-machine parallelism in the cloud computing solver test through the parsing operation and the scheduling operation, thereby achieving the technical effect of reducing the cloud computing solver test time and improving the cloud computing solver test efficiency, and thus solving the technical problem of low test efficiency of the related technology processing method of using a single-machine serial method to perform solver testing.

[0151] It should be noted that the embodiments of the present invention can be, but are not limited to, applicable to optimization solver test application scenarios in cloud computing. For example, it can also be applied to the following technical fields of application optimization solvers: electric power energy field (such as energy technology, energy management, energy generation, energy equipment, power transmission, power distribution, power measurement, etc.); industrial manufacturing field (such as agricultural and sideline food processing, food manufacturing, tobacco products, textiles, mechanical and electronic manufacturing, etc.); transportation and logistics field (such as railway transportation, road transportation, water transportation, air transportation, logistics collection, logistics distribution, etc.); retail field (such as commodity management, sales analysis, etc.); financial field (such as bank management, insurance analysis, securities analysis, etc.); medical field (such as medical data analysis, electronic medical records, appointment registration information management, etc.); education field (such as course data management, learning data analysis, etc.).

[0152] In an optional embodiment, a graphical user interface is provided by a client, and the content displayed by the graphical user interface at least partially includes a cloud computing test task parallel processing scenario, and the method for processing the test task also includes the following method steps:

[0153] Step S512, receiving the cloud computing program to be executed and the cloud computing model file to be tested uploaded on the client through the graphical user interface;

[0154] Step S514, receiving a cloud computing test task instruction inputted through a graphical user interface on a client, wherein the cloud computing test task instruction includes: cloud computing execution parameters, and the cloud computing execution parameters are used to determine the execution logic of the cloud computing program to be executed;

[0155] Step S516, scheduling some or all execution nodes to process multiple distributed cloud computing tasks in parallel using the cloud computing program to be executed, the execution logic of the cloud computing program to be executed, and the cloud computing model file to be tested, to obtain a cloud computing test result;

[0156] Step S518: Return the cloud computing test result to the client and display the cloud computing test result in a graphical user interface.

[0157] In the above optional embodiment, the graphical user interface content provided by the client may at least partially include the above cloud computing test task parallel processing scenario. The client may upload the cloud computing program to be executed and the cloud computing model file to be tested to the server through the graphical user interface. The client may also input a cloud computing test task instruction through the graphical user interface. The cloud computing test task instruction may include cloud computing execution parameters. The cloud computing execution parameters may be used to determine the execution logic of the cloud computing program to be executed.

[0158] In the above optional embodiment, after the server receives the cloud computing program to be executed and the cloud computing model file to be tested uploaded by the client through the graphical user interface, and receives the cloud computing test task instructions input by the client through the graphical user interface, it can schedule some or all of the above execution nodes to use the cloud computing program to be executed, the execution logic of the cloud computing program to be executed and the cloud computing model file to be tested to process the above multiple distributed cloud computing tasks in parallel, and then obtain the cloud computing test results.

[0159] In the above optional embodiment, the server can return the obtained cloud computing test result to the client. The client can display the cloud computing test result returned by the server to the user through a graphical user interface.

[0160] Optionally, the cloud computing program to be executed and the cloud computing model file to be tested may also be obtained by the server by parsing the execution of the cloud computing test task. The multiple distributed cloud computing tasks correspond to the cloud computing test tasks and can be processed in parallel. Some or all of the execution nodes may be execution nodes selected from the target distributed cluster, and the some or all of the execution nodes may be used to process the multiple distributed cloud computing tasks in parallel. The cloud computing test results may be the parallel processing results of the cloud computing test tasks.

[0161] Under the above operating environment, the present invention provides Figure 6 A method of handling test tasks is shown. Figure 6 is a flowchart of another method for processing a test task according to an embodiment of the present invention. Figure 6 As shown, the method for processing the test task includes:

[0162] Step S602, receiving an electric power test task request from a client, wherein the information carried in the electric power test task request includes: an electric power test task instruction;

[0163] Step S604, parsing the electric power test task instruction to generate a plurality of distributed electric power tasks to be executed;

[0164] Step S606, scheduling some or all execution nodes in the target distributed cluster to process multiple distributed electric energy tasks in parallel to obtain electric energy test results.

[0165] In the above optional embodiment, the power energy test task request may be a request message issued by the client based on the power energy test task, and the power energy test task may be a task corresponding to a certain test of the power energy solver. The information carried in the power energy test task request may include a power energy test task instruction, and the power energy test task instruction may be a computer executable instruction corresponding to the power energy test task.

[0166] In the above optional embodiment, the electric power test task instruction is parsed to generate multiple distributed electric power tasks to be executed. The multiple distributed electric power tasks can be processed in parallel. The above target distributed cluster can be a computer cluster for executing the above electric power test task, and the computer cluster can include multiple execution nodes. The execution node can be a physical machine for computing. By scheduling some or all of the execution nodes in the target distributed cluster, the multiple distributed electric power tasks can be processed in parallel, and then the above electric power test result can be obtained.

[0167] It is easy to notice that in the above optional embodiment, multiple distributed power energy tasks are obtained by parsing the power energy test task instruction. The multiple distributed power energy tasks correspond to the power energy test task and can be processed in parallel. Through the above method for processing the power energy test task, when the number of power energy solver test models is large, multi-machine parallel computing can be realized, which greatly reduces the test time and improves the test efficiency compared with the single-machine serial computing in the related art.

[0168] It should be noted that the above method for processing power energy test tasks can be run on the server side to receive and respond to power energy test task requests issued by the client. In actual application scenarios, the server side can correspond to multiple clients and use its powerful computing performance to solve power energy test task requests issued by multiple clients, thereby greatly improving the efficiency of power energy solver development and testing.

[0169] In an embodiment of the present invention, an electric energy test task request is first received from a client, wherein the information carried in the electric energy test task request includes: an electric energy test task instruction, and a plurality of distributed electric energy tasks to be executed are generated by parsing the electric energy test task instruction. A method of scheduling some or all execution nodes in a target distributed cluster to process the plurality of distributed electric energy tasks in parallel is adopted to obtain an electric energy test result.

[0170] It is easy to notice that, through the embodiments of the present application, analysis is performed based on the electric energy test task request issued by the client, and then the test is executed and the electric energy test result is obtained through the scheduling operation, thereby achieving the purpose of realizing multi-machine parallelism in the electric energy solver test through the analysis operation and the scheduling operation, thereby achieving the technical effect of reducing the electric energy solver test time and improving the electric energy solver test efficiency, and thus solving the technical problem of low test efficiency of the related technology processing method of using a single machine serial method to perform solver testing.

[0171] It should be noted that the embodiments of the present invention can be applied to, but not limited to, energy technology, energy management, energy generation, energy equipment, power transmission, power distribution, power measurement and other application scenarios in the field of electric power and energy. For example, it can also be applied to the following technical fields of application optimization solvers: cloud computing; industrial manufacturing (such as agricultural and sideline food processing, food manufacturing, tobacco products, textiles, mechanical and electronic manufacturing, etc.); transportation and logistics (such as railway transportation, road transportation, water transportation, air transportation, logistics collection, logistics distribution, etc.); retail (such as commodity management, sales analysis, etc.); financial (such as bank management, insurance analysis, securities analysis, etc.); medical (such as medical data analysis, electronic medical records, appointment registration information management, etc.); education (such as course data management, learning data analysis, etc.).

[0172] It should be noted that, for the above-mentioned method embodiments, for the sake of simplicity, they are all described as a series of action combinations, but those skilled in the art should know that the present invention is not limited by the described action sequence, because according to the present invention, certain steps can be performed in other sequences or simultaneously. Secondly, those skilled in the art should also know that the embodiments described in the specification are all preferred embodiments, and the actions and modules involved are not necessarily required by the present invention.

[0173] Through the description of the above implementation methods, those skilled in the art can clearly understand that the method according to the above embodiment can be implemented by means of software plus a necessary general hardware platform, and of course can also be implemented by hardware, but in many cases the former is a better implementation method. Based on such an understanding, the technical solution of the present invention, or the part that contributes to the prior art, can be embodied in the form of a software product, which is stored in a storage medium (such as ROM / RAM, a magnetic disk, or an optical disk), and includes a number of instructions for enabling a terminal device (which can be a mobile phone, a computer, a server, or a network device, etc.) to execute the methods described in each embodiment of the present invention.

[0174] Example 2

[0175] According to an embodiment of the present invention, there is also provided an apparatus embodiment for implementing the above method for processing a test task. Figure 7 is a schematic diagram of the structure of a device for processing a test task according to an embodiment of the present invention, such as Figure 7 As shown, the device includes: a receiving module 701, a parsing module 702, and a processing module 703, wherein:

[0176] The receiving module 701 is used to receive a test task request from a client, wherein the information carried in the test task request includes: a test task instruction; a parsing module 702 is used to parse the test task instruction and generate multiple distributed tasks to be executed; and a processing module 703 is used to schedule some or all execution nodes in the target distributed cluster to process multiple distributed tasks in parallel to obtain test results.

[0177] Optionally, the parsing module 703 is also used to parse the test task instructions to obtain a parsing result, wherein the parsing result includes: first information, second information and third information, the first information is used to determine the program to be executed, the second information is used to determine the execution logic of the program to be executed, and the third information is used to determine the model file to be tested; based on the first information, the second information and the third information, the test task instructions are expanded into multiple sub-commands; and multiple distributed tasks are generated using multiple sub-commands.

[0178] Optionally, Figure 8 is a schematic diagram of the structure of another device for processing a test task according to an embodiment of the present invention. Figure 8 As shown, the device includes Figure 7 In addition to all the modules shown, it also includes: a first storage module 704, used to store the analysis results in a first storage area, wherein the first storage area stores data in a table format; in response to a new task query request, when it is determined that the analysis results are queried from the first storage area, the parameter information associated with multiple distributed tasks is stored in a second storage area, wherein the second storage area stores data in a memory format, and the parameter information includes: first information, second information, third information, fourth information and fifth information, the fourth information is used to determine the task identifiers of multiple distributed tasks, and the fifth information is used to determine the task timeout period of multiple distributed tasks.

[0179] Optionally, Fig. 9 is a schematic diagram of the structure of another device for processing a test task according to an embodiment of the present invention. Fig. 9 As shown, the device includes Figure 8 In addition to all the modules shown, it also includes: a selection module 705, which is used to determine the number of available execution nodes in the target distributed cluster and the computing resources to be used for multiple distributed tasks; based on the number of available execution nodes and the computing resources to be used, select some or all execution nodes from the target distributed cluster.

[0180] Optionally, the processing module 703 is also used to obtain parameter information from the second storage area; determine the program to be executed, the execution logic of the program to be executed, and the model file to be tested through the parameter information; based on the execution environment corresponding to each distributed task in the multiple distributed tasks, schedule some or all execution nodes to use the program to be executed, the execution logic of the program to be executed, and the model file to be tested to process multiple distributed tasks in parallel to obtain test results.

[0181] Optionally, Fig.10 is a schematic diagram of the structure of another device for processing a test task according to an embodiment of the present invention. Fig.10 As shown, the device includes Fig. 9 In addition to all the modules shown, it also includes: a second storage module 706, which is used to store the first data in the test results in a third storage area, and to store the second data in the test results in a second storage area, wherein the third storage area stores data in the form of files, the first data is unstructured data in the test results, and the second data is structured data in the test results.

[0182] Optionally, Fig.11 is a schematic diagram of the structure of another device for processing a test task according to an embodiment of the present invention. Fig.11 As shown, the device includes Fig.10 In addition to all the modules shown, it also includes: an update module 707, which is used to transfer the second data from the second storage area to the first storage area in response to the test result update message; query the second data from the first storage area, and feed back the second data to the client.

[0183] It should be noted that the receiving module 701, the parsing module 702, and the processing module 703 correspond to steps S202 to S206 in Example 1, and the three modules and the corresponding steps implement the same examples and application scenarios, but are not limited to the contents disclosed in the above-mentioned Example 1. It should be noted that the above-mentioned modules, as part of the device, can be run in the computer terminal 10 provided in Example 1.

[0184] In an embodiment of the present invention, a receiving module is first used to receive a test task request from a client, wherein the information carried in the test task request includes: a test task instruction, the test task instruction is parsed by a parsing module to generate a plurality of distributed tasks to be executed, and a processing module is used to schedule some or all execution nodes in a target distributed cluster to process the plurality of distributed tasks in parallel to obtain a test result.

[0185] It is easy to notice that, through the embodiments of the present application, analysis is performed based on the test task request issued by the client, and then the test is executed and the test results are obtained through the scheduling operation, thereby achieving the purpose of realizing multi-machine parallelism in the optimization solver test through the analysis operation and the scheduling operation, thereby achieving the technical effect of reducing the optimization solver test time and improving the optimization solver test efficiency, and thus solving the technical problem of low test efficiency of the related technology processing method of using a single-machine serial method to perform solver testing.

[0186] It should be noted that the preferred implementation of this embodiment can refer to the relevant description in Example 1, which will not be repeated here.

[0187] Example 3

[0188] According to an embodiment of the present invention, an embodiment of an electronic device is also provided, and the electronic device may be any computing device in a computing device group. The electronic device includes: a processor and a memory, wherein:

[0189] A memory is connected to the above-mentioned processor and is used to provide the above-mentioned processor with instructions for processing the following processing steps: receiving a test task request from a client, wherein the information carried in the test task request includes: test task instructions; parsing the test task instructions to generate multiple distributed tasks to be executed; scheduling some or all execution nodes in the target distributed cluster to process multiple distributed tasks in parallel to obtain test results.

[0190] In an embodiment of the present invention, a test task request is first received from a client, wherein the information carried in the test task request includes: test task instructions, and multiple distributed tasks to be executed are generated by parsing the test task instructions. A method of scheduling some or all execution nodes in a target distributed cluster to process multiple distributed tasks in parallel is adopted to obtain a test result.

[0191] It is easy to notice that, through the embodiments of the present application, analysis is performed based on the test task request issued by the client, and then the test is executed and the test results are obtained through the scheduling operation, thereby achieving the purpose of realizing multi-machine parallelism in the optimization solver test through the analysis operation and the scheduling operation, thereby achieving the technical effect of reducing the optimization solver test time and improving the optimization solver test efficiency, and thus solving the technical problem of low test efficiency of the related technology processing method of using a single-machine serial method to perform solver testing.

[0192] It should be noted that the preferred implementation of this embodiment can refer to the relevant description in Example 1, which will not be repeated here.

[0193] Example 4

[0194] The embodiment of the present invention can provide a computer terminal, which can be any computer terminal device in a computer terminal group. Optionally, in this embodiment, the computer terminal can also be replaced by a terminal device such as a mobile terminal.

[0195] Optionally, in this embodiment, the computer terminal may be located in at least one network device among a plurality of network devices of the computer network.

[0196] In this embodiment, the above-mentioned computer terminal can execute the program code of the following steps in the method for processing a test task: receiving a test task request from a client, wherein the information carried in the test task request includes: test task instructions; parsing the test task instructions to generate multiple distributed tasks to be executed; scheduling some or all execution nodes in the target distributed cluster to process multiple distributed tasks in parallel to obtain test results.

[0197] Optionally, Fig.12 is a structural block diagram of another computer terminal according to an embodiment of the present invention. Fig.12 As shown, the computer terminal may include: one or more (only one is shown in the figure) processors 122 , a memory 124 , and a peripheral interface 126 .

[0198] Among them, the memory can be used to store software programs and modules, such as the program instructions / modules corresponding to the method and device for processing test tasks in the embodiments of the present invention. The processor executes various functional applications and data processing by running the software programs and modules stored in the memory, that is, realizing the above-mentioned method for processing test tasks. The memory may include a high-speed random access memory, and may also include a non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some instances, the memory may further include a memory remotely arranged relative to the processor, and these remote memories may be connected to the computer terminal via a network. Examples of the above-mentioned network include, but are not limited to, the Internet, an intranet, a local area network, a mobile communication network, and combinations thereof.

[0199] The processor can call the information and application programs stored in the memory through the transmission device to execute the following steps: receive a test task request from the client, wherein the information carried in the test task request includes: test task instructions; parse the test task instructions to generate multiple distributed tasks to be executed; schedule some or all execution nodes in the target distributed cluster to process multiple distributed tasks in parallel to obtain test results.

[0200] Optionally, the processor may also execute the program code of the following steps: parsing the test task instructions to obtain parsing results, wherein the parsing results include: first information, second information and third information, the first information is used to determine the program to be executed, the second information is used to determine the execution logic of the program to be executed, and the third information is used to determine the model file to be tested; based on the first information, the second information and the third information, the test task instructions are expanded into multiple sub-commands; and multiple distributed tasks are generated using multiple sub-commands.

[0201] Optionally, the processor may also execute the program code of the following steps: storing the analysis results in a first storage area, wherein the first storage area stores data in a table format; in response to a new task query request, when it is determined that the analysis results are queried from the first storage area, storing parameter information associated with multiple distributed tasks in a second storage area, wherein the second storage area stores data in a memory format, and the parameter information includes: first information, second information, third information, fourth information and fifth information, the fourth information is used to determine the task identifiers of multiple distributed tasks, and the fifth information is used to determine the task timeout of multiple distributed tasks.

[0202] Optionally, the processor may also execute program code of the following steps: determining the number of available execution nodes in the target distributed cluster and the computing resources to be used for multiple distributed tasks; and selecting some or all execution nodes from the target distributed cluster based on the number of available execution nodes and the computing resources to be used.

[0203] Optionally, the processor may also execute the program code of the following steps: obtaining parameter information from the second storage area; determining the program to be executed, the execution logic of the program to be executed, and the model file to be tested through the parameter information; based on the execution environment corresponding to each distributed task in the multiple distributed tasks, scheduling part or all of the execution nodes to use the program to be executed, the execution logic of the program to be executed, and the model file to be tested to process multiple distributed tasks in parallel to obtain test results.

[0204] Optionally, the processor may also execute the following program code: storing the first data in the test results to a third storage area, and storing the second data in the test results to a second storage area, wherein the third storage area stores data in the form of files, the first data is unstructured data in the test results, and the second data is structured data in the test results.

[0205] Optionally, the processor may also execute program codes of the following steps: in response to a test result update message, transferring the second data from the second storage area to the first storage area; querying the second data from the first storage area, and feeding back the second data to the client.

[0206] Optionally, the processor may also execute the program code of the following steps: receiving a program to be executed and a model file to be tested uploaded on the client through a graphical user interface; receiving a test task instruction input on the client through a graphical user interface, wherein the test task instruction includes: execution parameters, the execution parameters are used to determine the execution logic of the program to be executed; scheduling some or all execution nodes to process multiple distributed tasks in parallel using the program to be executed, the execution logic of the program to be executed and the model file to be tested to obtain test results; returning the test results to the client and displaying the test results in the graphical user interface.

[0207] Optionally, the processor may also execute program code for the following steps: in the process of parallel processing of multiple distributed tasks, in response to adjustment operations performed on the client through a graphical user interface, updating the program to be executed and / or multiple distributed tasks, wherein updating multiple distributed tasks includes at least one of the following: adding new distributed tasks based on multiple distributed tasks, terminating the execution of some of the distributed tasks being executed among the multiple distributed tasks.

[0208] The processor can call the information and application programs stored in the memory through the transmission device to execute the following steps: receiving a cloud computing test task request from the client, wherein the information carried in the cloud computing test task request includes: cloud computing test task instructions; parsing the cloud computing test task instructions to generate multiple distributed cloud computing tasks to be executed; scheduling some or all execution nodes in the target distributed cluster to process multiple distributed cloud computing tasks in parallel to obtain cloud computing test results.

[0209] Optionally, the processor may also execute program codes for the following steps: receiving a cloud computing program to be executed and a cloud computing model file to be tested uploaded on the client through a graphical user interface; receiving a cloud computing test task instruction input on the client through a graphical user interface, wherein the cloud computing test task instruction includes: cloud computing execution parameters, which are used to determine the execution logic of the cloud computing program to be executed; scheduling some or all execution nodes to use the cloud computing program to be executed, the execution logic of the cloud computing program to be executed, and the cloud computing model file to be tested to process multiple distributed cloud computing tasks in parallel to obtain cloud computing test results; returning the cloud computing test results to the client, and displaying the cloud computing test results in the graphical user interface.

[0210] The processor can call the information and application programs stored in the memory through the transmission device to execute the following steps: receiving an electric power test task request from the client, wherein the information carried in the electric power test task request includes: electric power test task instructions; parsing the electric power test task instructions to generate multiple distributed electric power tasks to be executed; scheduling some or all execution nodes in the target distributed cluster to process multiple distributed electric power tasks in parallel to obtain electric power test results.

[0211] In an embodiment of the present invention, a test task request is first received from a client, wherein the information carried in the test task request includes: test task instructions, and multiple distributed tasks to be executed are generated by parsing the test task instructions. A method of scheduling some or all execution nodes in a target distributed cluster to process multiple distributed tasks in parallel is adopted to obtain a test result.

[0212] It is easy to notice that, through the embodiments of the present application, analysis is performed based on the test task request issued by the client, and then the test is executed and the test results are obtained through the scheduling operation, thereby achieving the purpose of realizing multi-machine parallelism in the optimization solver test through the analysis operation and the scheduling operation, thereby achieving the technical effect of reducing the optimization solver test time and improving the optimization solver test efficiency, and thus solving the technical problem of low test efficiency of the related technology processing method of using a single-machine serial method to perform solver testing.

[0213] It can be understood by those skilled in the art that Fig.12 The structure shown is for illustration only, and the computer terminal may also be a smart phone (such as an Android phone, an iOS phone, etc.), a tablet computer, a PDA, a mobile Internet device (Mobile Internet Devices, MID), a PAD, or other terminal devices. Fig.12 It does not limit the structure of the above electronic device. For example, the computer terminal may also include Fig.12 More or fewer components (such as network interfaces, display devices, etc.) shown in, or having Fig.12 Different configurations are shown.

[0214] A person of ordinary skill in the art can understand that all or part of the steps in the various methods of the above embodiments can be completed by instructing the hardware related to the terminal device through a program, and the program can be stored in a computer-readable storage medium, and the storage medium may include: a flash drive, a read-only memory (ROM), a random access memory (RAM), a magnetic disk or an optical disk, etc.

[0215] According to an embodiment of the present invention, an embodiment of a computer-readable storage medium is also provided. Optionally, in this embodiment, the computer-readable storage medium can be used to store program codes executed by the method for processing a test task provided in the first embodiment.

[0216] Optionally, in this embodiment, the computer-readable storage medium may be located in any one of the computer terminals in a computer terminal group in a computer network, or in any one of the mobile terminals in a mobile terminal group.

[0217] Optionally, in this embodiment, a computer-readable storage medium is configured to store program code for performing the following steps: receiving a test task request from a client, wherein the information carried in the test task request includes: test task instructions; parsing the test task instructions to generate multiple distributed tasks to be executed; scheduling some or all execution nodes in the target distributed cluster to process multiple distributed tasks in parallel to obtain test results.

[0218] Optionally, in this embodiment, the computer-readable storage medium is configured to store program codes for performing the following steps:

[0219] Optionally, in this embodiment, a computer-readable storage medium is configured to store program code for performing the following steps: receiving a test task request from a client, wherein the information carried in the test task request includes: test task instructions; parsing the test task instructions to generate multiple distributed tasks to be executed; scheduling some or all execution nodes in the target distributed cluster to process multiple distributed tasks in parallel to obtain test results.

[0220] Optionally, in this embodiment, the computer-readable storage medium is configured to store program code for performing the following steps: parsing the test task instructions to obtain parsing results, wherein the parsing results include: first information, second information, and third information, the first information is used to determine the program to be executed, the second information is used to determine the execution logic of the program to be executed, and the third information is used to determine the model file to be tested; based on the first information, the second information, and the third information, the test task instructions are expanded into multiple sub-commands; and multiple distributed tasks are generated using multiple sub-commands.

[0221] Optionally, in this embodiment, a computer-readable storage medium is configured to store program code for performing the following steps: storing the parsing results in a first storage area, wherein the first storage area stores data in a tabular form; in response to a new task query request, when it is determined that the parsing results are queried from the first storage area, storing parameter information associated with multiple distributed tasks in a second storage area, wherein the second storage area stores data in a memory form, and the parameter information includes: first information, second information, third information, fourth information and fifth information, the fourth information is used to determine the task identifiers of multiple distributed tasks, and the fifth information is used to determine the task timeout of multiple distributed tasks.

[0222] Optionally, in this embodiment, the computer-readable storage medium is configured to store program code for performing the following steps: determining the number of available execution nodes in the target distributed cluster and the computing resources to be used for multiple distributed tasks; selecting some or all of the execution nodes from the target distributed cluster based on the number of available execution nodes and the computing resources to be used.

[0223] Optionally, in this embodiment, the computer-readable storage medium is configured to store program code for executing the following steps: obtaining parameter information from a second storage area; determining a program to be executed, the execution logic of the program to be executed, and a model file to be tested through the parameter information; based on the execution environment corresponding to each distributed task in a plurality of distributed tasks, scheduling some or all execution nodes to use the program to be executed, the execution logic of the program to be executed, and the model file to be tested to process multiple distributed tasks in parallel to obtain test results.

[0224] Optionally, in this embodiment, the computer-readable storage medium is configured to store program code for performing the following steps: storing first data in the test results in a third storage area, and storing second data in the test results in a second storage area, wherein the third storage area stores data in the form of files, the first data is unstructured data in the test results, and the second data is structured data in the test results.

[0225] Optionally, in this embodiment, the computer-readable storage medium is configured to store program code for performing the following steps: in response to a test result update message, transferring the second data from the second storage area to the first storage area; querying the second data from the first storage area, and feeding back the second data to the client.

[0226] Optionally, in this embodiment, the computer-readable storage medium is configured to store program code for executing the following steps: receiving a program to be executed and a model file to be tested uploaded on the client through a graphical user interface; receiving a test task instruction input on the client through a graphical user interface, wherein the test task instruction includes: execution parameters, the execution parameters are used to determine the execution logic of the program to be executed; scheduling some or all execution nodes to use the program to be executed, the execution logic of the program to be executed and the model file to be tested to process multiple distributed tasks in parallel to obtain test results; returning the test results to the client, and displaying the test results in the graphical user interface.

[0227] Optionally, in this embodiment, the computer-readable storage medium is configured to store program code for performing the following steps: in the process of parallel processing of multiple distributed tasks, in response to an adjustment operation performed on the client through a graphical user interface, updating the to-be-executed program and / or multiple distributed tasks, wherein updating the multiple distributed tasks includes at least one of the following: adding new distributed tasks based on the multiple distributed tasks, terminating the execution of some of the distributed tasks being executed among the multiple distributed tasks.

[0228] Optionally, in this embodiment, a computer-readable storage medium is configured to store program code for executing the following steps: receiving a cloud computing test task request from a client, wherein the information carried in the cloud computing test task request includes: cloud computing test task instructions; parsing the cloud computing test task instructions to generate multiple distributed cloud computing tasks to be executed; scheduling some or all execution nodes in the target distributed cluster to process multiple distributed cloud computing tasks in parallel to obtain cloud computing test results.

[0229] Optionally, in this embodiment, the computer-readable storage medium is configured to store program codes for executing the following steps: receiving a cloud computing program to be executed and a cloud computing model file to be tested uploaded on the client through a graphical user interface; receiving a cloud computing test task instruction input on the client through a graphical user interface, wherein the cloud computing test task instruction includes: cloud computing execution parameters, which are used to determine the execution logic of the cloud computing program to be executed; scheduling some or all execution nodes to use the cloud computing program to be executed, the execution logic of the cloud computing program to be executed, and the cloud computing model file to be tested to process multiple distributed cloud computing tasks in parallel to obtain cloud computing test results; returning the cloud computing test results to the client, and displaying the cloud computing test results in the graphical user interface.

[0230] Optionally, in this embodiment, the computer-readable storage medium is configured to store program code for executing the following steps: receiving an electric energy test task request from a client, wherein the information carried in the electric energy test task request includes: an electric energy test task instruction; parsing the electric energy test task instruction to generate multiple distributed electric energy tasks to be executed; scheduling some or all execution nodes in the target distributed cluster to process multiple distributed electric energy tasks in parallel to obtain electric energy test results.

[0231] The serial numbers of the above embodiments of the present invention are only for description and do not represent the advantages or disadvantages of the embodiments.

[0232] In the above embodiments of the present invention, the description of each embodiment has its own emphasis. For parts that are not described in detail in a certain embodiment, reference can be made to the relevant descriptions of other embodiments.

[0233] In the several embodiments provided in this application, it should be understood that the disclosed technical content can be implemented in other ways. Among them, the device embodiments described above are only schematic. For example, the division of the units is only a logical function division. There may be other division methods in actual implementation. For example, multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be through some interfaces, indirect coupling or communication connection of units or modules, which can be electrical or other forms.

[0234] The units described as separate components may or may not be physically separated, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed on multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution of this embodiment.

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

[0236] If the integrated unit is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention, in essence, 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, and the computer software product is stored in a storage medium, including a number of instructions for a computer device (which can be a personal computer, a server or a network device, etc.) to perform all or part of the steps of the method described in each embodiment of the present invention. The aforementioned storage medium includes: U disk, read-only memory (ROM, Read-Only Memory), random access memory (RAM, Random Access Memory), mobile hard disk, magnetic disk or optical disk and other media that can store program codes.

[0237] The above is only a preferred embodiment of the present invention. It should be pointed out that for ordinary technicians in this technical field, several improvements and modifications can be made without departing from the principle of the present invention. These improvements and modifications should also be regarded as the scope of protection of the present invention.

Claims

1. A method for processing a test task, characterized in that: include: Receiving a test task request from a client, wherein the information carried in the test task request includes: a test task instruction; The analysis result obtained by parsing the test task instruction is stored in a first storage area, wherein the first storage area stores data in a table form, wherein the analysis result includes: first information, second information and third information, wherein the first information is used to determine the program to be executed, the second information is used to determine the execution logic of the program to be executed, and the third information is used to determine the model file to be tested; According to the analysis result, a plurality of distributed tasks to be executed are generated; In response to a new task query request, when it is determined that the parsing result is queried from the first storage area, the parameter information associated with the plurality of distributed tasks is stored in a second storage area, wherein the second storage area stores data in a memory form; Some or all execution nodes in the target distributed cluster are scheduled to process the multiple distributed tasks in parallel to obtain test results.

2. The method according to claim 1, characterized in that Parsing the test task instruction to generate the multiple distributed tasks includes: Parsing the test task instruction to obtain a parsing result; Based on the first information, the second information and the third information, expanding the test task instruction into a plurality of sub-commands; The plurality of distributed tasks are generated using the plurality of subcommands.

3. The method according to claim 2, characterized in that The method further comprises: Storing the analysis result in a first storage area, wherein the first storage area stores data in a table format; In response to a new task query request, when it is determined that the analysis result is queried from the first storage area, the parameter information associated with the multiple distributed tasks is stored in the second storage area, wherein the second storage area stores data in the form of memory, and the parameter information includes: the first information, the second information, the third information, the fourth information and the fifth information, the fourth information is used to determine the task identifiers of the multiple distributed tasks, and the fifth information is used to determine the task timeout period of the multiple distributed tasks.

4. The method according to claim 3, characterized in that The method further comprises: Determining the number of available execution nodes in the target distributed cluster and the computing resources to be used by the plurality of distributed tasks; The part or all of the execution nodes are selected from the target distributed cluster based on the number of available execution nodes and the computing resources to be used.

5. The method according to claim 4, characterized in that Scheduling some or all execution nodes in the target distributed cluster to process the multiple distributed tasks in parallel, and obtaining the test result includes: Acquire the parameter information from the second storage area; Determining the program to be executed, the execution logic of the program to be executed, and the model file to be tested through the parameter information; Based on the execution environment corresponding to each distributed task in the multiple distributed tasks, schedule some or all of the execution nodes to process the multiple distributed tasks in parallel using the program to be executed, the execution logic of the program to be executed and the model file to be tested to obtain the test result.

6. The method according to claim 5, characterized in that The method further comprises: The first data in the test result is stored in a third storage area, and the second data in the test result is stored in the second storage area, wherein the third storage area stores data in the form of files, the first data is unstructured data in the test result, and the second data is structured data in the test result.

7. The method according to claim 6, characterized in that The method further comprises: In response to a test result update message, transferring the second data from the second storage area to the first storage area; The second data is queried from the first storage area, and the second data is fed back to the client.

8. The method according to claim 2, characterized in that: A graphical user interface is provided by the client, wherein the content displayed by the graphical user interface at least partially includes a test task parallel processing scenario, and the method further includes: Receiving the program to be executed and the model file to be tested uploaded on the client through the graphical user interface; Receiving the test task instruction inputted through the graphical user interface on the client, wherein the test task instruction includes: execution parameters, the execution parameters are used to determine the execution logic of the program to be executed; Scheduling some or all of the execution nodes to process the multiple distributed tasks in parallel using the program to be executed, the execution logic of the program to be executed and the model file to be tested to obtain the test result; The test result is returned to the client and displayed in the graphical user interface.

9. The method according to claim 8, characterized in that The method further comprises: In the process of parallel processing of the multiple distributed tasks, in response to the adjustment operation performed on the client through the graphical user interface, the to-be-executed program and / or the multiple distributed tasks are updated, wherein updating the multiple distributed tasks includes at least one of the following: adding new distributed tasks based on the multiple distributed tasks, terminating the execution of some of the distributed tasks being executed among the multiple distributed tasks.

10. A method for processing a test task, characterized in that: include: Receiving a cloud computing test task request from a client, wherein the information carried in the cloud computing test task request includes: a cloud computing test task instruction; The analysis result obtained by parsing the cloud computing test task instruction is stored in a first storage area, wherein the first storage area stores data in a table form, wherein the analysis result includes: first information, second information and third information, wherein the first information is used to determine the program to be executed, the second information is used to determine the execution logic of the program to be executed, and the third information is used to determine the model file to be tested; According to the analysis result, a plurality of distributed cloud computing tasks to be executed are generated; In response to a new task query request, when it is determined that the parsing result is queried from the first storage area, the parameter information associated with the plurality of distributed cloud computing tasks is stored in a second storage area, wherein the second storage area stores data in a memory form; Some or all execution nodes in the target distributed cluster are scheduled to process the multiple distributed cloud computing tasks in parallel to obtain cloud computing test results.

11. The method according to claim 10, characterized in that A graphical user interface is provided by the client, wherein the content displayed by the graphical user interface at least partially includes a cloud computing test task parallel processing scenario, and the method further includes: Receiving a cloud computing program to be executed and a cloud computing model file to be tested uploaded on the client through the graphical user interface; Receiving the cloud computing test task instruction inputted through the graphical user interface on the client, wherein the cloud computing test task instruction includes: cloud computing execution parameters, the cloud computing execution parameters are used to determine the execution logic of the cloud computing program to be executed; Scheduling some or all of the execution nodes to process the multiple distributed cloud computing tasks in parallel using the cloud computing program to be executed, the execution logic of the cloud computing program to be executed, and the cloud computing model file to be tested to obtain the cloud computing test result; The cloud computing test result is returned to the client, and the cloud computing test result is displayed in the graphical user interface.

12. A method for processing a test task, characterized in that: include: Receiving an electric power energy test task request from a client, wherein the information carried in the electric power energy test task request includes: an electric power energy test task instruction; Parsing the electric energy test task instruction, and storing the obtained parsing result in a first storage area, wherein the first storage area stores data in a table form, wherein the parsing result includes: first information, second information, and third information, wherein the first information is used to determine the program to be executed, the second information is used to determine the execution logic of the program to be executed, and the third information is used to determine the model file to be tested; According to the analysis results, a plurality of distributed electric energy tasks to be executed are generated; In response to a new task query request, when it is determined that the parsing result is queried from the first storage area, the parameter information associated with the plurality of distributed electric energy tasks is stored in a second storage area, wherein the second storage area stores data in a memory form; Some or all execution nodes in the target distributed cluster are scheduled to process the multiple distributed electric energy tasks in parallel to obtain electric energy test results.

13. A system for processing a test task, characterized in that: include: processor; as well as A memory, connected to the processor, configured to provide the processor with instructions for processing the following processing steps: Step 1, receiving a test task request from a client, wherein the information carried in the test task request includes: a test task instruction; Step 2, parsing the test task instruction, and storing the obtained parsing result in a first storage area, wherein the first storage area stores data in a table form, wherein the parsing result includes: first information, second information and third information, wherein the first information is used to determine the program to be executed, the second information is used to determine the execution logic of the program to be executed, and the third information is used to determine the model file to be tested; based on the parsing result, generating multiple distributed tasks to be executed; in response to a new task query request, when it is determined that the parsing result is queried from the first storage area, storing the parameter information associated with the multiple distributed tasks in a second storage area, wherein the second storage area stores data in a memory form; Step 3: Schedule some or all execution nodes in the target distributed cluster to process the multiple distributed tasks in parallel to obtain test results.

Images