CN115809197A

CN115809197A - Automatic debugging method, device, terminal, system and storage medium

Info

Publication number: CN115809197A
Application number: CN202211584639.XA
Authority: CN
Inventors: 高强
Original assignee: Shanghai United Imaging Healthcare Co Ltd
Current assignee: Shanghai United Imaging Healthcare Co Ltd
Priority date: 2022-12-09
Filing date: 2022-12-09
Publication date: 2023-03-17

Abstract

The invention provides an automatic debugging method, an automatic debugging device, a terminal, a system and a storage medium. The automatic debugging method comprises the steps of firstly, acquiring a standard data set of a source program and a test data set of a target program; then generating a verification report according to the standard data set and the test data set; the verification report comprises a debugging result of each piece of test data in the test data set and position information of a code generating the test data in the target program. The invention can help research and development engineers to quickly and effectively locate problems, can obviously save manpower and material resources, and improves the debugging efficiency of software escape.

Description

Automatic debugging method, device, terminal, system and storage medium

Technical Field

The invention relates to the technical field of computers, in particular to an automatic debugging method, an automatic debugging device, an automatic debugging terminal, an automatic debugging system and a storage medium.

Background

During the development of the algorithm, after an algorithm engineer transfers a completed workable algorithm (often an inefficient program, such as a Matlab program) to a development engineer (usually a software engineer or, in some cases, a hardware engineer), the development engineer needs to have a deep knowledge of the current code and convert it (e.g., optimize or escape step by step) so as to be able to apply to an actual product. Therefore, the algorithm optimization work is an essential link for transferring the algorithm to the product, and is an important component for the efficient operation of the algorithm. However, in actual practice, the result of the converted program operation is often far from the result of the execution of the original program of the algorithm. Because the algorithm itself is complex and has a high code amount, and the converted program and the original program of the algorithm usually use different programming languages and even run on different operating systems, the cause of the result error cannot be analyzed by using a debugging method (such as a log search method, program fault debug removal, etc.) of the conventional software, in order to search the cause of the error, in the prior art, when the converted final result and the algorithm execution result provided by an algorithm engineer are found to be very different, a research and development engineer usually has to store intermediate results in the original algorithm code and the escape code respectively, and manually compare the intermediate results of the algorithm. Obviously, this manual operation requires an experienced engineer to spend a long time locating the specific location where the problem occurs, and is very inefficient.

It is noted that the information disclosed in this background section is only for enhancement of understanding of the general background of the invention and should not be taken as an acknowledgement or any form of suggestion that this information forms the prior art already known to a person skilled in the art.

Disclosure of Invention

The invention aims to provide an automatic debugging method, device, terminal, system and storage medium aiming at the problem of low debugging efficiency in algorithm optimization in the prior art, so as to improve the debugging efficiency of algorithm optimization and save the cost of manpower and material resources.

In order to achieve the purpose, the invention is realized by the following technical scheme: an automated debugging method, comprising:

acquiring a standard data set of a source program and a test data set of a target program;

generating a verification report according to the standard data set and the test data set; the verification report comprises a debugging result of each piece of test data in the test data set and position information of a code generating the test data in the target program.

Optionally, the acquiring a test data set of the target program includes:

acquiring a data characteristic description list of a standard data set of a source program of a specified version;

and acquiring the test data set according to the characteristic description list of the standard data set.

Optionally, the standard data set and the test data set are stored in the form of files;

the data feature description manifest comprising: storage information of the files and attribute information of data in each of the files.

Optionally, the method further comprises:

when each piece of standard data in the standard data set and the test data in the test data set are obtained, whether the iteration times of code execution for generating the standard data and the test data are determined is judged, and if yes, the attribute information further comprises the iteration times corresponding to the code for generating the standard data and the test data.

Optionally, the generating a verification report according to the standard data set and the test data set includes:

comparing whether the test data in the test data set is consistent with the corresponding standard data in the standard data set, if so, the debugging result is that the test is passed; if not, the debugging result is test failure, and the position of a code generating the test data in the target program is obtained according to the attribute information of the test data;

and generating the check report according to the debugging result and the position of the code generating the test data in the target program.

In order to achieve the above object, the present invention further provides an automatic debugging apparatus, including:

the data generation module is configured to acquire a standard data set of a source program and a test data set of a target program;

the data checking module is configured to generate a checking report according to the standard data set and the test data set; the verification report comprises a debugging result of each piece of test data in the test data set and position information of a code generating the test data in the target program.

Optionally, the data generation module includes a data generation interface sub-module and a data collection service sub-module, the data verification module includes a data verification interface sub-module and a data verification service sub-module, and the automatic debugging device further includes a data storage and configuration module; wherein the content of the first and second substances,

the data generation interface sub-module is used for respectively providing a standard data acquisition interface for the source program and a test data acquisition interface for the target program so as to acquire standard raw data of the source program and test raw data of the target program;

the data collection service sub-module is configured to respectively process the standard raw data to obtain a standard data set and the test raw data to obtain a test data set according to the preset debugging data acquisition rule; the data storage and configuration module is also used for sending the standard data set and the test data set to the data storage and configuration module;

the data storage and configuration module is configured to store configuration information of the automated debugging device and at least one of the standard data set, the test data set and the verification report;

the data verification service sub-module is used for acquiring the standard data set and the test data set from the data storage and configuration module, generating verification report generation data according to the standard data set and the test data set, and sending the verification report generation data to the data verification interface sub-module;

the data verification interface sub-module is configured to generate a verification report according to the data generated by the verification report, and is used for storing the verification report to the data storage and configuration module through the data verification service sub-module.

In order to achieve the above object, the present invention further provides an automated debugging terminal, including a processor and a memory, wherein the memory stores one or both of a source program and a target program, and a data generation program; and/or the memory has a data verification program stored thereon;

the source program is configured to invoke the data generation program when being executed by the processor;

the object program is configured to call the data generating program when being executed by the processor;

the data generating program is configured to be called by the source program and executed by the processor to execute the following steps: acquiring a standard data set of the source program; and/or configured to be invoked by the target program to perform the following steps when executed by the processor: acquiring a test data set of the target program;

the data verification program, when executed by the processor, is configured to perform the steps of:

generating a verification report according to the standard data set of the source program and the test data set of the target program; the verification report comprises a debugging result of each piece of test data in the test data set and position information of a code generating the test data in the target program.

In order to achieve the above object, the present invention further provides an automated debugging system, including: a source program terminal, a target program terminal and a debugging server terminal which are in communication connection; wherein the content of the first and second substances,

the source program terminal is configured to acquire a standard data set of a source program and send the standard data set to the debugging server;

the target program terminal is configured to acquire a test data set of a target program and send the test data set to the debugging server;

the debugging service terminal is configured to generate a check report according to the standard data set and the test data set, and send the check report to the target program terminal; the verification report comprises a debugging result of each piece of test data in the test data set and position information of a code generating the test data in the target program.

Optionally, the target program terminal is configured to obtain a test data set of the target program, and includes:

the target program terminal is configured to request the debugging server for a data feature description list of a standard data set of a source program of a specified version;

In order to achieve the above object, the present invention further provides a computer readable storage medium, in which a computer program is stored, and the computer program, when executed by a processor, implements the automated debugging method of any one of the above.

Compared with the prior art, the automatic debugging method, the device, the terminal, the system and the storage medium provided by the invention have the following advantages:

the invention provides an automatic debugging method, which comprises the steps of firstly, acquiring a standard data set of a source program and a test data set of a target program; then generating a verification report according to the standard data set and the test data set; the verification report comprises a debugging result of each piece of test data in the test data set and position information of a code generating the test data in the target program. Therefore, the automatic debugging method provided by the invention provides a reference standard for testing whether the target program is correct or not by acquiring the standard data set of the source program, and lays a good foundation for carrying out automatic debugging on the target program by acquiring the test data set of the target program. And then generating a verification report according to the standard data set and the test data set, wherein the verification report comprises a debugging result of each piece of test data in the test data set and position information of a code generating the test data in the target program. The verification report is obtained according to the standard data set and the test data set, so that the reliability of the debugging result in the verification report is high; the debugging result and the corresponding position information (the position of the code generating the test data in the target program, such as a file, a function, a code line and the like) in the verification report can help a research and development engineer to quickly and accurately position the problem, so that manpower and material resources can be remarkably saved, and the debugging efficiency of software optimization is improved.

Furthermore, the method comprises the steps of firstly obtaining a data characteristic description list of a standard data set of a source program of a specified version; and then, the test data set is obtained according to the characteristic description list of the standard data set, so that the standard data set is identified (distinguished) through the version, respective upgrade iteration of a source program and a target program can be facilitated, and the version of the test data set can be ensured to be matched with the standard data set through the version, so that errors of a check report caused by different versions of the standard data set and the test data set during data verification can be prevented, and the version control is simple, convenient and easy to implement and convenient to maintain.

Further, the automated debugging apparatus provided by the present invention includes a data generation module and a data verification module, the data generation module includes a data generation interface sub-module (for example, implemented in an application layer of a software architecture) and a data collection service sub-module (for example, implemented in a service layer of the software architecture), and the data verification module includes a data verification interface sub-module (for example, implemented in the application layer of the software architecture) and a data verification service sub-module (for example, implemented in the service layer of the software architecture). Therefore, the automatic debugging device provided by the invention can support the source program (algorithm program) realized by different programming languages through the data generation interface sub-module of the data generation module (such as providing scripts of a plurality of programming languages for an algorithm engineer) through the separation of the interface and the logic processing, and has better cross-platform performance. Furthermore, the automatic debugging system provided by the invention comprises a source program terminal, a target program terminal and a debugging service terminal which are in communication connection, and the distributed characteristic can enable a research and development engineer of the target program to carry out online or offline automatic debugging so as to verify whether the target program has errors or not; moreover, cluster deployment can be supported, and high concurrency access can be conveniently carried out by research and development engineers in different areas and different target programs.

In conclusion, the automatic debugging method, the automatic debugging device, the terminal, the automatic debugging system and the storage medium provided by the invention realize an end-to-end automatic debugging process, the whole process does not need manual participation, the debugging efficiency of research and development engineers can be obviously improved, and the manpower and material resource cost is saved.

Drawings

FIG. 1 is a schematic diagram of a basic principle of an automated debugging method provided by the present invention;

fig. 2 is a schematic flowchart of an automated debugging method according to an embodiment of the present invention;

fig. 3 is a schematic flowchart of an automated debugging method according to an embodiment of the present invention, wherein the flowchart illustrates that standard data with a known data size is obtained;

fig. 4 is a schematic structural diagram of an automated debugging apparatus according to a second embodiment of the present invention;

fig. 5 is a schematic structural diagram of an automated debugging terminal according to a third embodiment of the present invention;

fig. 6 is a schematic structural diagram of an automated debugging system according to a fourth embodiment of the present invention;

fig. 7 is a schematic diagram of an application scenario in accordance with a fourth embodiment of the present invention;

wherein the reference numbers are as follows:

the system comprises a data generation module-100, a data generation interface sub-module-110, a data collection service sub-module-120, a data verification module-200, a data verification interface sub-module-210, a data verification service sub-module-220 and a data storage and configuration module-300;

processor-410, communication interface-420, memory-430, communication bus-440;

a source program terminal-500, a target program terminal-600 and a debugging service terminal-700.

Detailed Description

The automated debugging method, apparatus, terminal, system, storage medium and storage medium according to the present invention are further described in detail with reference to the accompanying drawings. The advantages and features of the present invention will become more apparent from the following description. It is to be noted that the drawings are in a very simplified form and are all used in a non-precise scale for the purpose of facilitating and distinctly aiding in the description of the embodiments of the present invention. To make the objects, features and advantages of the present invention comprehensible, reference is made to the accompanying drawings. It should be understood that the structures, proportions, sizes, and other elements shown in the drawings and described herein are illustrative only and are not intended to limit the scope of the invention, which is to be given the full breadth of the appended claims and any and all modifications, equivalents, and alternatives to those skilled in the art should be construed as falling within the spirit and scope of the invention. Specific design features of the invention disclosed herein, including, for example, specific dimensions, orientations, locations, and configurations, will be determined in part by the particular intended application and use environment. In the embodiments described below, the same reference numerals are used in common between different drawings to denote the same portions or portions having the same functions, and a repetitive description thereof will be omitted. In this specification, like reference numerals and letters are used to designate like items, and therefore, once an item is defined in one drawing, further discussion thereof is not required in subsequent drawings. Additionally, if the method described herein comprises a series of steps, the order in which these steps are presented herein is not necessarily the only order in which these steps may be performed, and some of the described steps may be omitted and/or some other steps not described herein may be added to the method.

It is noted that, herein, relational terms such as first and second, and the like may be used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Also, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising a … …" does not exclude the presence of another identical element in a process, method, article, or apparatus that comprises the element. The singular forms "a," "an," and "the" include plural referents, the term "or" is generally employed in a sense including "and/or," the terms "a number" and "an" are generally employed in a sense including "at least one," the terms "at least two" are generally employed in a sense including "two or more," and further, the terms "first," "second," and "third" are used for descriptive purposes only and are not to be construed as indicating or implying relative importance or to imply that the number of technical features indicated are all.

It should be particularly noted that, as can be understood by those skilled in the art, python, matlab and C + + are used as examples in the prior art, and although they are the most popular programming languages used in the software development process, they have a respective emphasis, for example, python and Matlab contain rich and easy-to-use math libraries, which enable developers to quickly implement their ideas, quickly bring methods to the ground, and more algorithm engineers are used. And C + + is a programming language for efficiently executing an algorithm, so that the algorithm implemented by Python or Matlab needs to be converted into C + + in engineering to optimize the algorithm, so that the program has higher operating efficiency.

The core idea of the invention is to improve the debugging efficiency of algorithm optimization to save the cost of manpower and material resources, and provide an automatic debugging method, device, terminal, system and storage medium. The basic principle of the invention is that: an algorithm engineer can add codes for storing standard data in a related flow of a source program to obtain a standard data set through the method, and a research and development engineer also adds corresponding codes in a flow corresponding to a target program to obtain a test data set in an algorithm escape stage by using the method and performs dynamic analysis on the data when the target program is executed, so that the specific position of an error code is positioned efficiently. Specifically, please refer to fig. 1, which schematically shows a basic principle diagram of the automated debugging method provided by the present invention. As can be seen from fig. 1, first, a standard data set of a source program (such as Python or Matlab) and a test data set of a target program (such as C + +) are obtained by a data generation tool, and then a data verification tool automatically obtains a verification report according to the test data set and the standard data set.

It should be particularly noted that the critical path identified by the solid line in fig. 1 is a necessary path of the automated debugging algorithm provided by the present invention, and the optional path identified by the dashed line is an optional path, that is, determined according to the programming language of the source program, for example, if the source program uses Python, a path from the data generation tool to the standard data set through Python is a necessary path, and correspondingly, a path from the data generation tool to the standard data set through Matlab does not exist. And vice versa.

Further, although C + + is taken as an example of the programming language of the target program, and Python and Matlab are taken as examples of the programming language of the source program, it is obvious that this is not a limitation of the present invention, the present invention does not set any limitation to the programming language used by the source program and the target program, and the programming language of the target program may also be other than C + +, such as, but not limited to, java and the like; likewise, the programming language of the source program may be other programming languages besides Python and Matlab, including but not limited to Java, etc. Further, the programming languages of the target program and the source program may be the same or different, such as: the programming languages of the source program and the target program are both C + +.

Example one

The present embodiment provides an automated debugging method, and specifically, please refer to fig. 2, which schematically shows a flow diagram of the automated debugging method provided in the present embodiment. As can be seen from fig. 2, the automated debugging method provided by this embodiment includes:

s100: acquiring a standard data set of a source program and a test data set of a target program; the target program is obtained by conversion according to the source program;

s200: generating a verification report according to the standard data set and the test data set; the verification report comprises a debugging result of each piece of test data in the test data set and position information of a code generating the test data in the target program.

Therefore, the automatic debugging method provided by the embodiment provides a reference standard for testing whether the target program is correct by acquiring the standard data set of the source program, and lays a good foundation for automatic debugging of the target program by acquiring the test data set of the target program. And then generating a verification report according to the standard data set and the test data set, wherein the verification report comprises a debugging result of each piece of test data in the test data set and position information of a code generating the test data in the target program. The verification report is obtained according to the standard data set and the test data set, so that the reliability of the debugging result in the verification report is high; the debugging result and the corresponding position information (the position of the code generating the test data in the target program, such as a file, a function, a code line and the like) in the verification report can help a research and development engineer to quickly and accurately position the problem, so that manpower and material resources can be remarkably saved, and the debugging efficiency of software optimization is improved.

Based on the above description, those skilled in the art should understand that the target program corresponds to the source program, the target program is transformed from the source program, and the target program is optimized (transformed) by the development engineer, and is not a direct transformation using some existing tools or techniques. Optimization requires an engineer to find the adjustment changes to the source program by the optimal path of program execution, rather than a piecemeal translation, in conjunction with the hardware resources of the production environment, as well as the logic of the program.

It should be particularly noted that the present invention does not limit the specific content of the debugging result, and in one embodiment, the debugging result may include only a debugging conclusion, such as one of Success (Success) and failure (Fail); in other embodiments, the number of tests and the debugging conclusion of each time can be included; in some embodiments, in addition to the debugging result, when the obtained debugging result is a failure, more detailed contents may be included, such as the content of the test data in the test data set, the content of the corresponding standard data in the standard data set, and specific deviation information between the test data in the test data set and the corresponding standard data in the standard data set.

In one exemplary implementation, step S100, acquiring the test data set of the target program includes:

s110: acquiring a data characteristic description list of a standard data set of a source program of a specified version;

s120: and acquiring the test data set according to the characteristic description list of the standard data set.

Therefore, the embodiment obtains the data feature description list of the standard data set of the source program of the specified version; and then, the test data set is obtained according to the characteristic description list of the standard data set, so that the standard data set is identified (distinguished) through the version, respective upgrade iteration of a source program and a target program can be facilitated, and the version of the test data set can be ensured to be matched with the standard data set through the version, so that errors of a check report caused by different versions of the standard data set and the test data set during data verification can be prevented, and the version control is simple, convenient and easy to implement and convenient to maintain.

As will be understood by those skilled in the art, a change in user requirements or an upgrade of a software version (such as optimization of a source program or an object program itself, or bug repair of the source program itself, etc.) may cause a change in the source program (such as using Matlab or Python implementation), and such a change may cause a standard data set of the source program to be updated untimely, thereby causing a verification that the object program (C + + implemented code) is mistaken in generating a verification report. In the automatic debugging method provided by this embodiment, the standard data set is identified (distinguished) by the version, and the test data set is obtained according to the feature description list of the standard data set during verification, so that misjudgment caused by mismatching of the versions of the standard data set and the test data set is avoided, and thus, the debugging efficiency of program escape can be further improved.

In one preferred embodiment, the standard data set and the test data set are stored in the form of files;

the data feature description list includes, but is not limited to, storage information of the files and attribute information of data in each of the files.

Therefore, the automatic debugging process provided by the embodiment stores the standard data set and the test data set in a file manner, and lays a solid foundation for the subsequent online and/or offline generation of the verification report. Furthermore, the test data set is obtained according to the attribute information of each piece of data in each file, so that the test data set is more matched with the standard data set, and generation of a subsequent verification report can be better guided.

It is specifically noted that the foregoing is illustrative only and not limiting of the invention, which is not limiting of the invention, as those skilled in the art will appreciate, and that the invention is not limited to the specific details of the data feature description list set forth. For example, in one preferred embodiment, the storage information of the file includes the number of standard files for storing the standard data set, and description information (such as file name, storage path, etc.) of each file; the attribute information of each piece of data includes list information of attributes. More specifically, the attribute list information includes the number of attributes, the meaning of each attribute, the order of the attributes, and the like. The attributes include the name of the code file, the line of code, etc. that generated the test data.

Further, in step S100, the obtaining a standard data set of the source program and a test data set of the target program includes:

when each piece of standard data in the standard data set and each piece of test data in the test data set are obtained, whether the iteration times of code execution for generating the standard data and the test data are determined is judged, and if yes, the attribute information further comprises the iteration times corresponding to the code for generating the standard data and the test data.

According to the automatic debugging method provided by the embodiment, aiming at the condition that a target language (such as C + +) has multithreading concurrency, codes of test data generated by a part of algorithms can be completely cached not through one-time operation but can be completed through multiple iterations, and the size of the test data can be divided into known and unknown conditions according to the scenes that the iteration times of the algorithms are fixed and unfixed. For example, if the number of iterations executed by the code generating the test data is determined, the attribute information of each piece of test data further includes the number of iterations corresponding to the code generating the piece of test data. For example, data 1 is the first execution and data 2 is the second execution, … …. Based on this, when the target program acquires the test data set, the mode of generating the test data set can be reasonably selected according to the actual code of the target program. Therefore, the obtained debugging result of the check report can further comprise that the code corresponding to the result is obtained when the code is executed for the second time, and the debugging efficiency is further improved. The principle of obtaining the standard data set is similar, and can be understood by referring to the method for generating the test data set, and the details are not described herein.

It should be noted that the procedure for obtaining the standard data set is similar and will not be described again. The present invention is not limited to the specific implementation of the above-mentioned obtaining of the test data set and the standard data set, and the above-mentioned obtaining process of the standard data set may be executed by a separate logic processing module (for example, as the data collecting service sub-module 120 in the following second embodiment), and the target program and the source program obtain the test data set and the standard data set by calling the logic processing module.

Referring to fig. 3, a schematic flow chart of an automated debugging method provided in an embodiment of the invention for obtaining standard data with a known data size (e.g., N times of iteration) is schematically shown. As can be seen from fig. 3: a source program firstly calls an API interface (for example, a function interface provided by the data generation interface sub-module 110 in the second embodiment), then a logic processing module (for example, the data collection service sub-module 120 in the second embodiment) creates a file directory, searches a current file storage table (including the number of files, identifiers of the files, and the like), if a corresponding file does not exist, creates the file, and updates the file storage table (the number of the files is increased by 1, and the file identifiers are added to the file) and stores data; and then judging whether all data are stored completely (comparing the size of the stored data with the known data size, for example, whether the size reaches N times), if so, finishing the storage of the current data, and deleting the corresponding file from the current file storage table (subtracting 1 from the number of the files, and deleting the corresponding file identifier). If all data are not finished, when the next iteration is carried out, when the current file storage table is searched, the file already exists, and the data are directly stored according to the attribute information of the data in the current file. Specifically, in step S200, the generating a verification report according to the standard data set and the test data set includes:

Therefore, according to the automatic debugging method provided by the embodiment, the check report not only indicates whether the debugging result passes, but also indicates the position of the code generating the test data in the target program when the test data in the test data set is inconsistent with the standard data corresponding to the standard data set, so that a research and development engineer can quickly and efficiently locate the specific position where the problem occurs, and labor and time costs are saved.

It should be noted that, the comparison of whether the test data in the test data set is consistent with the corresponding standard data in the standard data set actually means whether the result generated by the actual execution matches the result generated by the standard data (e.g., generated by matlab). The specific content of the test data and the standard data is not limited, and in some embodiments, the test data and the standard data may be standard values, for example: if the target program adopts C + + language, the value generated by the L2 model of the reconstructed data and the value generated by the L2 model of the reconstructed data in matlab adopted by the source program are different, and the absolute value of the difference between the two values is less than 1.e-5, the two values are consistent, and the debugging result is that the test is passed. In some other embodiments, the test data and the standard data may be images, and the debugging result is considered as a test pass by comparing the difference between the pixel points of the image of the test data and the pixel points of the image of the standard data in a preset range.

More specifically, the location of the code generating the test data in the target program includes, but is not limited to, the name of the target file where the code is located, the line number of the code in the target file, the directory where the target file is located, and the version number.

In conclusion, the automatic debugging method provided by the invention realizes an end-to-end automatic debugging process, does not need manual participation in the whole process, can obviously improve the debugging efficiency of research and development engineers, and saves the labor and material cost.

Example two

The present embodiment provides an automatic debugging apparatus, and specifically, please refer to fig. 4, which schematically shows a structural diagram of the automatic debugging apparatus provided by the present invention. As can be seen from fig. 4, the automated debugging apparatus provided in this embodiment includes: a data generation module 100 and a data verification module 200.

Specifically, the data generating module 100 is configured to obtain a standard data set of a source program and a test data set of a target program; and the target program is obtained by conversion according to the source program. The data verification module 200 is configured to generate a verification report according to the standard data set and the test data set; the verification report comprises a debugging result of each piece of test data in the test data set and position information of a code generating the test data in the target program.

Since the automated debugging apparatus provided in this embodiment and the automated debugging method provided in the first embodiment belong to the same inventive concept, at least all advantages of the automated debugging method are provided, and specific contents refer to the above description of the automated debugging method, which is not repeated herein.

More specifically, the data generation module 100 includes a data generation interface sub-module 110 and a data gathering service sub-module 120, the data verification module 200 includes a data verification interface sub-module 210 and a data verification service sub-module 220, and the automated debugging apparatus further includes a data storage and configuration module 300. The following description of each submodule is provided:

the data generation interface sub-module 110 is configured to provide a standard data acquisition interface for the source program and a test data acquisition interface for the target program, respectively, so as to acquire standard raw data of the source program and test raw data of the target program. The data gathering service sub-module 120 is configured to process the standard raw data to obtain the standard data set and process the test raw data to obtain the test data set according to the preset debug data obtaining rule; and also for sending the standard data set and the test data set to the data storage and configuration module 300.

The data storage and configuration module 300 is configured to store configuration information of the automated debugging device and at least one of the standard data set, the test data set, and the verification report.

The data verification service sub-module 220 is configured to obtain the standard data set and the test data set from the data storage and configuration module 300, generate verification report generation data according to the standard data set and the test data set, and send the verification report generation data to the data verification interface sub-module 210; the data verification interface sub-module 210 is configured to generate a verification report according to the verification report, and is configured to store the verification report to the data storage and configuration module 300 through the data verification service sub-module 220.

Therefore, the automated debugging apparatus provided by the present embodiment includes a data generation module 100 and a data verification module 200, where the data generation module 100 includes a data generation interface sub-module 110 (e.g., implemented in an application layer of a software architecture) and a data collection service sub-module 120 (e.g., implemented in a service layer of the software architecture), and the data verification module 200 includes a data verification interface sub-module 210 (e.g., implemented in the application layer of the software architecture) and a data verification service sub-module 220 (e.g., implemented in the service layer of the software architecture). Therefore, the automatic debugging device provided by the invention can support the source program (algorithm program) realized by different programming languages through the data generation interface sub-module 110 of the data generation module 100 (for example, providing scripts of multiple programming languages for algorithm engineers) through the separation of the interface and the logic processing, and has better cross-platform performance.

Specifically, please refer to fig. 4 continuously, as can be seen from fig. 4, the automatic debugging apparatus provided in this embodiment is implemented according to a three-layer architecture of software, and the data generation interface sub-module 110 and the data verification interface sub-module 210 are disposed in an application layer, and can provide a source program and a target program of multiple programming languages, so as to provide scripts of corresponding languages for an algorithm engineer and a research and development engineer, so as to conveniently implant the automatic debugging apparatus into the source program and the target program. The data collection service sub-module 120 and the data verification service sub-module 220 which are responsible for the logic processing are arranged in a service layer, and the logic processing (including but not limited to data collection, data comparison and the like) is separated from an application layer, so that the maintenance and the upgrade of the automatic debugging device are more convenient. For example, if a supported programming language of the source program and/or the target program is newly added, only the data generation interface sub-module 110 and/or the data verification interface sub-module 210 needs to be augmented by the corresponding programming language, and the data collection service sub-module 120 and the data verification service sub-module 220 arranged in the service layer do not need to be modified. Further, the data storage and configuration module 300 is disposed in a data layer, which facilitates the query and real-time migration of the standard data set, the test data set, the verification report, and the configuration information of the automatic debugging apparatus.

It should be particularly noted that, although a single-machine version automatic debugging apparatus is taken as an example in fig. 4 for illustration, this is not a limitation of the present invention, and in other implementation manners, the automatic debugging apparatus may also be implemented in a server-client manner, for example, the data generation module 100 is respectively disposed at terminals where the source program and the target program are located, the data verification module 200 and the data storage and configuration module 300 are disposed at the server (the data storage and configuration module 300 may also be disposed at another database server, and the database server is in communication connection with the server and the client), and the standard data set is obtained at the terminal where the source program is located and then sent to the server; the test data set is also sent to a server after being acquired at a terminal where the target program is located; the data verification module 200 disposed at the server generates the verification report according to the standard data set and the test data set. For more details on the server-client, please refer to the following description of the automated debugging system for better understanding, and the description thereof will not be provided herein.

EXAMPLE III

The present embodiment provides an automatic debugging terminal, and specifically, please refer to fig. 5, which schematically shows a block structure diagram of the automatic debugging terminal provided in the present embodiment. As shown in fig. 5, the automated debugging terminal includes a processor 410 and a memory 430, the memory 430 storing one or both of an active program and a target program and a data generating program; and/or the memory stores a data verification program; the target program converts the source program into the following descriptions of the source program, the target program and the data verification program respectively as follows:

the source program is configured to invoke the data generation program when executed by the processor. The object program is configured to invoke the data generation program when executed by the processor.

The data generating program is configured to be called by the source program and executed by the processor to execute the following steps: acquiring a standard data set of the source program; and/or configured to be invoked by the target program to perform the following steps when executed by the processor: and acquiring a test data set of the target program.

Since the automated debugging terminal provided in this embodiment and the automated debugging method provided in the first embodiment belong to the same inventive concept, the automated debugging terminal provided in this embodiment at least has all the advantages of the automated debugging method provided in the above embodiments, and for more details, reference is made to the description related to the above embodiments, and details are not repeated here.

As shown in fig. 5, the automated debugging terminal further includes a communication interface 420 and a communication bus 440, wherein the processor 410, the communication interface 420 and the memory 430 are communicated with each other through the communication bus 440. The communication bus 440 may be a Peripheral Component Interconnect (PCI) bus, an Extended Industry Standard Architecture (EISA) bus, or the like. The communication bus 440 may be divided into an address bus, a data bus, a control bus, and the like. For ease of illustration, only one thick line is shown, but this is not intended to represent only one bus or type of bus. The communication interface 420 is used for communication between the automatic debugging terminal and other devices.

The Processor 410 may be a Central Processing Unit (CPU), other general purpose Processor, a Digital Signal Processor (DSP), an Application Specific Integrated Circuit (ASIC), an off-the-shelf Programmable Gate Array (FPGA) or other Programmable logic device, discrete Gate or transistor logic device, discrete hardware component, etc. The general-purpose processor may be a microprocessor or the processor may be any conventional processor, etc., and the processor 410 is a control center of the automatic debugging terminal and connects various parts of the whole automatic debugging terminal by using various interfaces and lines.

The memory 430 may be used to store the computer program, and the processor 410 may implement various functions of the automated debugging terminal by running or executing the computer program stored in the memory 430 and calling up data stored in the memory 430.

The memory 430 may include non-volatile and/or volatile memory. Non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically Programmable ROM (EPROM), electrically Erasable Programmable ROM (EEPROM), or flash memory. Volatile memory can include Random Access Memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in a variety of forms such as Static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double Data Rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous Link DRAM (SLDRAM), rambus (Rambus) direct RAM (RDRAM), direct Rambus Dynamic RAM (DRDRAM), and Rambus Dynamic RAM (RDRAM), among others.

Example four

The present embodiment provides an automatic debugging system, and specifically, please refer to fig. 6, which schematically shows a structural diagram of the automatic debugging system provided in the present embodiment. As can be seen from fig. 6, the automated debugging system provided by the present embodiment includes: a source program terminal 500, a target program terminal 600 and a debugging service terminal 700 which are in communication connection.

Specifically, the source program terminal 500 is configured to obtain a standard data set of a source program and send the standard data set to the debugging server 700. The target program terminal 600 is configured to obtain a test data set of a target program and send the test data set to the debugging server 700; and the target program is obtained by conversion according to the source program. The debugging server 700 is configured to generate a verification report according to the standard data set and the test data set, and send the verification report to the target program terminal 600; the verification report comprises a debugging result of each piece of test data in the test data set and position information of a code generating the test data in the target program.

Therefore, the automated debugging system provided by the embodiment includes the source program terminal 500, the target program terminal 600 and the debugging server 700 which are in communication connection, and by the distributed characteristic, not only can a research and development engineer of a target program perform online or offline automated debugging so as to verify whether an error occurs in the target program; moreover, cluster deployment can be supported, and high concurrent access is facilitated for research and development engineers in different areas and different target programs.

More specifically, in one exemplary embodiment, the target program terminal 600 is configured to obtain a test data set of a target program, and includes:

the target program terminal 600 is configured to request the debugging server 700 for a data feature description list of a standard data set of a source program of a specified version;

In particular, as will be understood by those skilled in the art, since the target program is obtained by converting the source program, the version of the test data set should match the version of the target program, and the automated debugging system provided in this embodiment first obtains the description list of the standard data set before obtaining the test data set, which is more beneficial for the debugging server 700 to analyze the standard data set and the check data set, so as to avoid misjudgment caused by mismatch between the versions of the standard data set and the test data set, thereby further improving debugging efficiency in the process of program escaping.

Further, the present invention does not limit the number of the source program terminal 500 and the target program terminal 600, the number of the source program terminal 500 may be one or more, and the number of the target program terminal 600 may also be one or more. Still further, in a preferred embodiment, the automated debugging system may further include a database server for storing the standard data set and the test data set; of course, this is not a limitation of the present invention, in other embodiments, the test data set and the standard data set may also be stored in the local memory of the debugging service 700, and in still other embodiments, the test data set and the standard data set may also be stored in the cloud memory.

Specifically, please refer to fig. 7, which schematically shows an application scenario diagram of the automated debugging system provided in this example. As can be seen from fig. 7, the conventional flow of the automated debugging system is:

in the first stage, an algorithm engineer stores an acquired standard data set to a database server at a source program end;

in the second stage, a research and development engineer requests a feature description list of the standard data set from the data verification service of the debugging service end 700 at a target program end, and stores the obtained test data set to a database server according to the feature description list;

and in the third stage, the data verification service of the debugging service terminal 700 generates a verification report according to the standard data set and the verification data set, and sends the verification report to the target program terminal. And ending the automatic debugging process.

As can be understood by those skilled in the art, if there is a situation that the test data fails in the debugging result given by the verification report, the development engineer will modify the target program at the target program end and debug the target program again, and at this time, only the second stage and the third stage need to be executed, and the first stage does not need to be executed again. Similarly, if the test data of the debugging result of the verification report is successful after the automated debugging is finished, and a subsequent research and development engineer optimizes the target program based on the source program of the same version on this basis, only the second stage and the third stage need to be executed, and the first stage does not need to be executed again. This further improves the debugging efficiency.

EXAMPLE five

The present embodiment provides a computer-readable storage medium, in which a computer program is stored, and the computer program can implement the automatic debugging method described above when being executed by a processor.

The readable storage media of embodiments of the invention may take any combination of one or more computer-readable media. The readable medium may be a computer readable signal medium or a computer readable storage medium. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination of the foregoing. More specific examples (a non-exhaustive list) of the computer readable storage medium would include the following: an electrical connection having one or more wires, a portable computer hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In this context, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device.

A computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated data signal may take many forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device.

Computer program code for carrying out operations for aspects of the present invention may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, smalltalk, C + +, and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer through any type of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet service provider).

In summary, compared with the prior art, the automated debugging method, the apparatus, the terminal, the system and the storage medium provided by the invention have the following advantages: the automatic debugging method provided by the invention provides a reference standard for testing whether the target program is correct or not by acquiring the standard data set of the source program, and lays a good foundation for carrying out automatic debugging on the target program by acquiring the test data set of the target program. And then generating a verification report according to the standard data set and the test data set, wherein the verification report comprises a debugging result of each piece of test data in the test data set and position information of a code generating the test data in the target program. The verification report is obtained according to the standard data set and the test data set, so that the reliability of the debugging result in the verification report is high; the debugging result and the corresponding position information (the position of the code generating the test data in the target program, such as a file, a function, a code line and the like) in the verification report can help a research and development engineer to quickly and accurately position the problem, so that manpower and material resources can be remarkably saved, and the debugging efficiency of software optimization is improved.

Further, the automated debugging apparatus provided by the present invention includes a data generation module and a data verification module, the data generation module includes a data generation interface sub-module (for example, implemented in an application layer of a software architecture) and a data collection service sub-module (for example, implemented in a service layer of the software architecture), and the data verification module includes a data verification interface sub-module (for example, implemented in the application layer of the software architecture) and a data verification service sub-module (for example, implemented in the service layer of the software architecture). Therefore, the automatic debugging device provided by the invention can support the source program (algorithm program) realized by different programming languages through the data generation interface sub-module of the data generation module (such as providing scripts of a plurality of programming languages for an algorithm engineer) through the separation of the interface and the logic processing, and has better cross-platform performance. Furthermore, the automatic debugging system provided by the invention comprises a source program terminal, a target program terminal and a debugging service terminal which are in communication connection, and the distributed characteristic can enable a research and development engineer of the target program to carry out online or offline automatic debugging so as to verify whether the target program has errors or not; moreover, cluster deployment can be supported, and high concurrent access is facilitated for research and development engineers in different areas and different target programs.

It should be noted that the apparatuses and methods disclosed in the embodiments herein can be implemented in other ways. The apparatus embodiments described above are merely illustrative, and for example, the flowchart and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of apparatus, methods and computer program products according to various embodiments herein. In this regard, each block in the flowchart or block diagrams may represent a module, a program, or a portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.

In addition, the functional modules in the embodiments herein may be integrated together to form an independent part, or each module may exist separately, or two or more modules may be integrated to form an independent part.

The above description is only for the purpose of describing the preferred embodiments of the present invention, and is not intended to limit the scope of the present invention, and any variations and modifications made by those skilled in the art based on the above disclosure are within the scope of the present invention. It will be apparent to those skilled in the art that various changes and modifications may be made in the present invention without departing from the spirit and scope of the invention. Thus, if such modifications and variations fall within the scope of the present invention and its equivalent technology, it is intended that the present invention also include such modifications and variations.

Claims

1. An automated debugging method, comprising:

2. The automated debugging method of claim 1, wherein the obtaining of the test data set of the target program comprises:

3. The automated debugging method of claim 2, wherein the standard data set and the test data set are stored in the form of files;

the data characterization manifest comprising: storage information of the files and attribute information of data in each of the files.

4. The automated debugging method of claim 3, further comprising:

5. The automated debugging method of claim 1, wherein generating a verification report based on the standard dataset and the test dataset comprises:

6. An automated commissioning device, comprising:

7. The automated debugging device of claim 6, wherein the data generation module comprises a data generation interface sub-module and a data collection service sub-module, the data verification module comprises a data verification interface sub-module and a data verification service sub-module, and the automated debugging device further comprises a data storage and configuration module; wherein the content of the first and second substances,

the data generation interface submodule is used for respectively providing a standard data acquisition interface for the source program and a test data acquisition interface for the target program so as to acquire standard raw data of the source program and test raw data of the target program;

the data storage and configuration module is configured to store configuration information of the automation debugging device and at least one of the standard data set, the test data set and the verification report;

8. An automated debug terminal comprising a processor and a memory, said memory having stored thereon one or both of a source program and a target program and a data generation program; and/or the memory has a data verification program stored thereon;

9. An automated debugging system, comprising: a source program terminal, a target program terminal and a debugging server terminal which are in communication connection; wherein the content of the first and second substances,

10. A computer-readable storage medium, in which a computer program is stored, which, when executed by a processor, implements the automated commissioning method of any one of claims 1 to 5.