CN111240987B - Method and device for detecting migration program, electronic equipment and computer readable storage medium - Google Patents
Method and device for detecting migration program, electronic equipment and computer readable storage medium Download PDFInfo
- Publication number
- CN111240987B CN111240987B CN202010049678.4A CN202010049678A CN111240987B CN 111240987 B CN111240987 B CN 111240987B CN 202010049678 A CN202010049678 A CN 202010049678A CN 111240987 B CN111240987 B CN 111240987B
- Authority
- CN
- China
- Prior art keywords
- function
- detected
- program
- test result
- test
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 230000005012 migration Effects 0.000 title claims abstract description 96
- 238000000034 method Methods 0.000 title claims abstract description 65
- 238000012360 testing method Methods 0.000 claims abstract description 274
- 230000002159 abnormal effect Effects 0.000 claims abstract description 11
- 230000006870 function Effects 0.000 claims description 489
- 238000004891 communication Methods 0.000 claims description 17
- 238000013508 migration Methods 0.000 claims description 12
- 238000012986 modification Methods 0.000 claims description 12
- 230000004048 modification Effects 0.000 claims description 12
- 238000001514 detection method Methods 0.000 claims description 11
- 238000004590 computer program Methods 0.000 claims description 9
- 238000004458 analytical method Methods 0.000 claims description 5
- 238000010586 diagram Methods 0.000 description 10
- 230000008569 process Effects 0.000 description 9
- 238000012545 processing Methods 0.000 description 4
- 239000013598 vector Substances 0.000 description 4
- 230000009471 action Effects 0.000 description 3
- 230000005856 abnormality Effects 0.000 description 2
- 238000012937 correction Methods 0.000 description 2
- 238000004806 packaging method and process Methods 0.000 description 2
- 230000002093 peripheral effect Effects 0.000 description 2
- 239000013589 supplement Substances 0.000 description 2
- 238000002054 transplantation Methods 0.000 description 2
- 238000003491 array Methods 0.000 description 1
- 238000004422 calculation algorithm Methods 0.000 description 1
- 238000004364 calculation method Methods 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 238000013500 data storage Methods 0.000 description 1
- 230000001419 dependent effect Effects 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 238000005538 encapsulation Methods 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 238000000802 evaporation-induced self-assembly Methods 0.000 description 1
- 230000006872 improvement Effects 0.000 description 1
- 230000010354 integration Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 239000013307 optical fiber Substances 0.000 description 1
- 239000000047 product Substances 0.000 description 1
- 239000004065 semiconductor Substances 0.000 description 1
- 239000007787 solid Substances 0.000 description 1
- 238000012546 transfer Methods 0.000 description 1
- 238000012795 verification Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3684—Test management for test design, e.g. generating new test cases
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3688—Test management for test execution, e.g. scheduling of test suites
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3692—Test management for test results analysis
Abstract
The embodiment of the invention provides a method and a device for detecting a migration program, electronic equipment and a computer readable storage medium. The method comprises the following steps: analyzing codes of a transplanting program to obtain function information of a function to be detected, which is included in the transplanting program; according to the sequence that the depended function to be detected is higher than the depended function to be detected, aiming at each function to be detected in turn, generating a test case of the function to be detected according to the function information of the function to be detected; executing the test case under the original platform environment of the migration program by using the function to be detected to obtain a first test result, and executing the test case under the target platform environment of the migration program by using the function to be detected to obtain a second test result; comparing whether the first test result and the second test result are the same; and if the first test result and the second test result are different, determining that the function to be detected is abnormal. Program migration efficiency can be improved.
Description
Technical Field
The present invention relates to the field of program detection technology, and in particular, to a method and apparatus for detecting a migration program, an electronic device, and a computer readable storage medium.
Background
For practical purposes, the developer may need to migrate programs running in one environment to another environment for operation. For example, program A is a program running in a CPU (Central Processing Unit ) platform environment, limited to CPU platform performance, may require migration of program A to run in an FPGA (Field-Programmable Gate Array, field programmable Gate array) platform environment.
However, since there is a certain difference between the two environments, after the program is migrated to the new environment to run, some or all of the functions may not be realized. In the related art, the code of the transplanted program may be manually detected by a developer to find out the reason why the function is not realized, but the finding process needs a person having development experience to complete and may take much time. Resulting in less efficient program migration.
Disclosure of Invention
An object of an embodiment of the present invention is to provide a method, an apparatus, an electronic device, and a computer readable storage medium for detecting a migration program, so as to improve efficiency of program migration. The specific technical scheme is as follows:
In a first aspect of the present invention, there is provided a migration program detection method, the method comprising:
analyzing codes of a transplanting program to obtain function information of a function to be detected, which is included in the transplanting program;
according to the sequence that the depended function to be detected is higher than the depended function to be detected, aiming at each function to be detected in turn, generating a test case of the function to be detected according to the function information of the function to be detected;
executing the test case under the original platform environment of the migration program by using the function to be detected to obtain a first test result, and executing the test case under the target platform environment of the migration program by using the function to be detected to obtain a second test result;
comparing whether the first test result and the second test result are the same;
and if the first test result and the second test result are different, determining that the function to be detected is abnormal.
In a possible embodiment, after the parsing the code of the migration program to obtain the function information of the function to be detected included in the program to be detected, the method further includes:
displaying the function information;
Acquiring a modification instruction aiming at the function information input;
changing the function information according to the modification instruction to obtain changed function information;
the generating the test case of the function to be detected according to the function information comprises the following steps:
and generating the test case of the function to be detected according to the changed function information.
In a possible embodiment, the parsing the code of the migration program to obtain function information of the function to be detected included in the program to be detected includes:
traversing codes of a migration program, and acquiring one or more of the following information of a function to be detected, which is included in the migration program, as intermediate information of the function to be detected: the function name, the function adjacency parameter, the line number of the initial line of the function in the code, the line number of the final line of the function in the code and the return type;
traversing codes of the transplanting program, and determining calling relations between the function to be detected and other functions to be used as structural information of the function to be detected;
and taking the intermediate information and the structure information of the function to be detected as the function information.
In one possible embodiment, the original platform of the migration program is a CPU platform, and the executing the test case under the original platform environment of the migration program by using the function to be detected to obtain a first test result includes:
Generating a source program file of the function to be detected under the CPU platform according to the function information;
compiling the source program file to generate a first test program under the CPU platform;
and calling the first test program to execute the test case to obtain a first test result.
In one possible embodiment, the destination platform of the migration program is a field programmable gate array FPGA platform, and the executing the test case under the destination platform environment of the migration program by using the function to be detected to obtain the second test result includes:
according to the code of the transplanting program, the function to be detected is packaged, and a command file is obtained;
compiling the command file to generate a second test program under the FPGA platform;
and calling the second test program to execute the test case to obtain a second test result.
In one possible embodiment, before the step of generating, for each function to be detected, a test case of the function to be detected according to the function information of the function to be detected in order of the depended function to be detected in preference to the depended function to be detected, the method further includes:
Constructing a tree structure based on the dependency relationship among the functions to be detected, wherein each node in the tree structure corresponds to one function to be detected, and the function to be detected corresponding to each node depends on the function to be detected corresponding to the father node of the node;
traversing each node of the tree structure starting from a root node of the tree structure;
arranging each function to be detected according to the accessed sequence of the corresponding nodes when traversing the tree structure to obtain a function sequence to be detected;
the step of generating test cases of the function to be detected according to the function information of the function to be detected for each function to be detected in sequence in preference to the order of relying on the function to be detected according to the function to be detected, comprising:
and generating a test case of each function to be detected in the function sequence to be detected according to the function information of the function to be detected.
In one possible embodiment, the first test result is represented in the form of a first text file and the second test result is represented in the form of a second text file;
the comparing whether the first test result and the second test result are the same comprises:
Comparing text contents in the first text file and the second text file;
if the text content in the first text file is the same as the text content in the second text file, determining that the first test result is the same as the second test result;
and if the text contents in the first text file and the second text file are different, determining that the first test result and the second test result are different.
In a second aspect of the present invention, there is provided a migration program detection apparatus, the apparatus comprising:
the code analysis module is used for analyzing the codes of the transplanting program to obtain the function information of the function to be detected, which is included in the transplanting program;
the use case generation module is used for generating test use cases of the function to be detected according to the function information of the function to be detected, aiming at each function to be detected in turn according to the order of the function to be detected which is depended over the function to be detected;
the function test module is used for executing the test case under the original platform environment of the transplanting program by utilizing the function to be detected to obtain a first test result, and executing the test case under the target platform environment of the transplanting program by utilizing the function to be detected to obtain a second test result;
The result comparison module is used for comparing whether the first test result and the second test result are the same or not;
and the conclusion output module is used for determining that the function to be detected is abnormal if the first test result and the second test result are different.
In a possible embodiment, the code parsing module is specifically configured to traverse the code of the migration program, and obtain, as the intermediate information of the function to be detected, one or more of the following information of the function to be detected included in the migration program:
the function name, the function adjacency parameter, the line number of the initial line of the function in the code, the line number of the final line of the function in the code and the return type;
traversing codes of the transplanting program, and determining calling relations between the function to be detected and other functions to be used as structural information of the function to be detected;
and taking the intermediate information and the structure information of the function to be detected as function information.
In a possible embodiment, the original platform of the migration program is a CPU platform, and the function test module is specifically configured to generate, according to the function information, a source program file of the function to be detected under the CPU platform;
Compiling the source program file to generate a first test program under the CPU platform;
and calling the first test program to execute the test case to obtain a first test result.
In a possible embodiment, the destination platform of the migration program is a field programmable gate array FPGA platform, and the function test module is specifically configured to encapsulate the function to be detected according to the code of the migration program, to obtain a command file;
compiling the command file to generate a second test program under the FPGA platform;
and calling the second test program to execute the test case to obtain a second test result.
In a possible embodiment, the code parsing module is further configured to, before generating, for each function to be detected, a test case of the function to be detected according to the function information of the function to be detected in sequence in preference to the order of relying on the function to be detected, based on a dependency relationship between the functions to be detected, construct a tree structure, where each node in the tree structure corresponds to one function to be detected, and each node corresponds to a function to be detected, and depends on a function to be detected corresponding to a parent node of the node;
Traversing each node of the tree structure starting from a root node of the tree structure;
arranging each function to be detected according to the accessed sequence of the corresponding nodes when traversing the tree structure to obtain a function sequence to be detected;
the use case generation module is specifically configured to generate, for each function to be detected in the sequence of functions to be detected, a test use case of the function to be detected according to the function information of the function to be detected.
In a possible embodiment, the result comparison module is specifically configured to compare whether the first test result and the second test result are the same, and includes:
comparing text contents in the first text file and the second text file;
if the text content in the first text file is the same as the text content in the second text file, determining that the first test result is the same as the second test result;
and if the text contents in the first text file and the second text file are different, determining that the first test result and the second test result are different.
In a third aspect of the present invention, there is provided an electronic device comprising a processor, a communication interface, a memory and a communication bus, wherein the processor, the communication interface, and the memory communicate with each other via the communication bus;
A memory for storing a computer program;
a processor for implementing the method steps of any of the above first aspects when executing a program stored on a memory.
In a fourth aspect of the present invention, there is provided a computer readable storage medium, characterized in that it has stored therein a computer program which, when executed by a processor, implements the method steps of any of the first aspects described above.
The method, the device and the electronic equipment for detecting the transplanting program provided by the embodiment of the invention can automatically detect the transplanting program by taking the function as a unit and reasonably setting the detection sequence, so that the time spent for detection is shortened, and the efficiency of program transplanting is effectively improved. Of course, it is not necessary for any one product or method of practicing the invention to achieve all of the advantages set forth above at the same time.
Drawings
In order to more clearly illustrate the embodiments of the invention or the technical solutions in the prior art, the drawings that are required in the embodiments or the description of the prior art will be briefly described, it being obvious that the drawings in the following description are only some embodiments of the invention, and that other drawings may be obtained according to these drawings without inventive effort for a person skilled in the art.
FIG. 1 is a schematic flow chart of a method for detecting a migration procedure according to an embodiment of the present invention;
fig. 2 is a schematic flow chart of a code analysis method according to an embodiment of the present invention
FIG. 3a is a schematic diagram of an engineering structure of an engineering for detecting a migration procedure according to an embodiment of the present invention;
FIG. 3b is a schematic flow chart of another embodiment of a method for detecting a migration procedure;
FIG. 3c is a schematic engineering schematic diagram of the data preparation phase;
FIG. 3d is a schematic diagram of the engineering principle of the function detection stage;
fig. 4 is a schematic structural diagram of a transplantation procedure detection apparatus according to an embodiment of the present invention;
fig. 5 is a schematic structural diagram of an electronic device according to an embodiment of the present invention.
Detailed Description
The following description of the embodiments of the present invention will be made clearly and completely with reference to the accompanying drawings, in which it is apparent that the embodiments described are only some embodiments of the present invention, but not all embodiments. All other embodiments, which can be made by those skilled in the art based on the embodiments of the invention without making any inventive effort, are intended to be within the scope of the invention.
In order to more clearly describe the migration program detection method provided by the embodiment of the present invention, a possible application scenario will be described in the following by way of example, and the migration program detection method provided by the embodiment of the present invention may also be applied to other application scenarios, which is not limited in this example.
A developer may develop a program using OpenCL (Open Computing Language ) based on C/c++ to develop a program capable of realizing various predetermined functions. These programs were originally designed to run in a CPU platform environment and, for practical purposes, need to be migrated to an FPGA platform environment for execution. Because the CPU platform environment and the FPGA platform environment are different, when the program is transplanted to the FPGA platform environment for execution, part or all of the functions which can be realized when the program is executed in the CPU platform environment can not be realized, so that the transplanted program needs to be detected, and the potential problems in the transplanted program can be found and solved in time.
Referring to fig. 1, fig. 1 is a schematic flow chart of a method for detecting a migration procedure according to an embodiment of the present invention, which may include:
s101, analyzing codes of the transplanting program to obtain function information of the function to be detected, which is included in the transplanting program.
S102, according to the order that the depended function to be detected is prioritized over the depended function to be detected, generating test cases of the function to be detected according to the function information of the function to be detected for each function to be detected in sequence.
S103, executing the test case in the original platform environment of the transplanting program by utilizing the function to be detected, and obtaining a first test result.
S104, executing the test case under the destination platform environment of the migration program by utilizing the function to be detected, and obtaining a second test result.
S105, comparing whether the first test result and the second test result are the same.
S106, if the first test result and the second test result are different, determining that the function to be detected is abnormal.
It can be understood that if the first test result and the second test result are different, it can be considered that there is a difference between the function to be detected when running in the original platform environment and the target platform environment, where the difference may be caused by a problem that the function to be detected is abnormal, or may be caused by that the function on which the function to be detected depends is abnormal. In the embodiment of the invention, the functions are detected according to the sequence of the dependency relationship, so that the possibility of difference caused by abnormality of the function on which the function to be detected depends can be effectively eliminated, and the function to be detected can be considered to have abnormality in the transplanting process when the first test result and the second test result are different. Therefore, the embodiment is selected, and the automatic detection can be performed on the transplanting program by taking the function as a unit and reasonably setting the detection sequence, so that the time spent for detection is shortened, and the efficiency of program transplanting is effectively improved.
In S101, taking the migration program as an example of a program developed by OpenCL based on C/c++, the code of the migration program is represented in the form of a command file (file with a suffix of. Cl, hereinafter referred to as a. Cl file), and the. Cl file of the migration program may be parsed.
According to different application scenes, the function to be detected can be one function or a plurality of functions, and the function to be detected can be all functions in the migration program or part of functions in the migration program. It will be appreciated that the code corresponding to a function may be regarded as a description of the function in the form of a computer language, and thus the function information may be obtained by parsing the code. The process of resolving the code will be described in detail in the following embodiments, and will not be described here again.
In S102, a function depends on another function, meaning that the output to the other function needs to be used during the operation of the one function. For example, assuming that function a calls function B, the return value to the output of function B needs to be used during the operation of function a, so function a depends on function B.
The test cases of the functions to be detected are generated according to the function information, one or more test cases can be generated for each function to be detected, and the number of the generated test cases can be different for different functions to be detected. A test case may be used to specify an environment and inputs, and when the test case is executed, the function is caused to process the specified inputs under the environment specified by the test case.
The number of test cases generated may be different for each function to be detected. Aiming at a function to be detected, the more the generated test cases are, the more the test cases can cover, so that the function to be detected is detected more comprehensively. For a function to be detected, the fewer the generated test cases are, the calculation amount spent by the migration program detection can be reduced. The number of test cases generated for each function to be detected may be set according to actual demands or user experience.
In one possible embodiment, the function information may be represented by a tree structure, and each node in the tree structure corresponds to a function to be detected, and the function to be detected corresponding to each node depends on the function to be detected corresponding to the parent node of the node.
In this example, the method may be to traverse each node of the tree structure from the root node of the tree structure, and obtain a function sequence to be detected according to the corresponding function to be detected; and generating a test case of each function to be detected in the function sequence to be detected according to the function information of the function to be detected. It can be understood that, because the function to be detected corresponding to a node in the tree structure depends on the function corresponding to the parent node of the node, the function to be detected, which depends on other functions to be detected, is located behind the dependent functions to be detected in the function sequence to be detected obtained by traversing the tree structure.
By adopting the embodiment, the dependency relationship among the functions to be detected can be shown more simply and clearly through the tree structure, and the sequence of the functions to be detected can be completely and accurately determined by traversing the tree structure. It will be appreciated that in other possible application scenarios, the order of the individual functions to be detected may also be determined in other ways.
The function information can reflect the possible running environment and possible input of the function to be detected to a certain extent, so that the test case can be generated according to the function information of the function to be detected.
In S103, the original platform of the migration program may refer to the platform on which the migration program is located before the migration. Taking the example of transplanting the transplanting program from the CPU platform environment to the FPGA platform environment, the original platform is the CPU platform. It can be understood that the migration program should theoretically be able to work normally before migration, i.e. the migration program executes test cases in the original platform environment, and the obtained test result theory is accurate.
In S104, the destination platform of the migration program may refer to a platform to which the migration program needs to be migrated. Still taking the example of transplanting the transplanting program from the CPU platform environment to the FPGA platform environment, the target platform can be the FPGA platform. It should be understood that fig. 1 is only a flowchart of a migration program detection method according to an embodiment of the present invention, in other possible embodiments, S104 may be performed before S103, or may be performed in parallel with S103 or alternatively, which is not limited in this embodiment.
In S105, if a plurality of test cases are generated for one function to be detected, each of the first test result and the second test result includes a plurality of results of the plurality of test cases. At this time, the first test result is the same as the second test result, which means that the first test result and the second test result of each test case are the same.
For example, assume that 3 test cases are generated for function A to be tested, denoted as test cases 1-3, respectively. Assuming that the function A to be detected is utilized to execute the test case 1 under the original platform environment to obtain a first test result 1, the test case 2 is executed to obtain a first test result 2, and the test case 3 is executed to obtain a first test result 3. And assuming that the function A to be detected is utilized to execute the test case 1 under the environment of the target platform to obtain a second test result 1, the test case 2 is executed to obtain a second test result 2, and the test case 3 is executed to obtain a second test result 3. The first test result is identical to the second test result and may mean that the first test result 1 is identical to the second test result 1, and the first test result 2 is identical to the second test result 2, and the first test result 3 is identical to the second test result 3.
The manner of comparison may vary depending on the application scenario, and in one possible embodiment, the first test result may be in the form of a first text file and the second test result may be in the form of a second text file. The text content in the first text file and the text content in the second text file may be compared, and if the text content in the first text file and the text content in the second text file are the same, it is determined that the first test result and the second test result are the same. And if the text contents in the first text file and the second text file are different, determining that the first test result and the second test result are different.
When the text content is compared, the characters in the same order in the first text file and the second text file can be compared one by one. If the same homonymous characters in the first text file and the second text file are the same, determining that the text contents of the first text file and the second text file are the same. If at least one (or at least a preset number) of the same-order characters in the first text file and the second text file are different, determining that the text content of the first text file and the second text file is different.
In 106, if the first test result and the second test result of the function to be detected are different, it can be considered that, in at least one possible application scenario, the function to be detected running in the original platform environment faces the same input, and the output of the function to be detected running in the target platform environment is different. And as in the previous analysis, the transplanting program executes the test case under the original platform environment, and the obtained test result theory is accurate. Therefore, it can be considered that the function to be detected at this time is abnormal during the migration.
The following will describe a process of resolving a code, referring to fig. 2, fig. 2 is a schematic flow chart of a code resolving method according to an embodiment of the present invention, which may include:
S201, traversing codes of the transplanting program, and acquiring one or more pieces of information of the function to be detected, which are included in the transplanting program, as intermediate information in the function to be detected.
Wherein the one or more information may refer to one or more of the following information:
function name, function argument, line number of the beginning line of the function in the code, line number of the ending line of the function in the code, return type.
S202, traversing codes of the transplanting program, and determining calling relations between functions to be detected and other functions to be used as structural information of the functions to be detected.
The code of the first traversal of the migration degree can determine the function names of the functions in the migration program, and the calling relations among the functions can be obtained by sorting according to the determined function names. The call relationship may be represented in different forms, for example in the form of a tree structure. If one function calls another function, the one function is a child node of the other function in the tree structure.
S203, taking the intermediate information and the structure information of the function to be detected as function information.
In this example, the function information of the function to be detected is composed of intermediate information and structure information of the function to be detected.
It will be appreciated that the accuracy of the tools and/or methods used to parse the code may be limited, and that the function information obtained by parsing the code may be inaccurate or somewhat lacking. In view of this, in one possible embodiment, after analyzing the code of the migration program to obtain the function information of the function to be detected, the function information may be displayed, and the manner of displaying the function information may be different according to the application scenario, for example, the function information may be displayed in the form of a table by using an xls file. The developer determines whether to perform error correction or supplement with respect to the presented function information, and if error correction or supplement is required, a modification instruction may be input. The execution main body changes the function information according to the obtained modification instruction to obtain changed function information, and further generates a test case of the function to be detected according to the changed function information.
By adopting the embodiment, a developer can manually change the function information to obtain more accurate function information. Based on more accurate function information, more reasonable test cases can be generated so as to improve the accuracy of the detection result.
In order to more clearly explain the migration program detection method provided by the embodiment of the present invention, the migration program detection method provided by the embodiment of the present invention will be described in detail below in connection with an application scenario in which a program developed through OpenCL based on C/c++ is migrated from a CPU platform environment to an FPGA platform environment. The application scenario is only one possible application scenario of the migration program detection method provided by the embodiment of the present invention, and may be applied to other application scenarios in other possible embodiments, which is not limited in this embodiment.
In this application scenario, assuming that an Project for detecting a migration program is called a verifiationproject, the Project directory structure of the verifiationproject may be as shown in fig. 3a, where a solid line box represents an original Project file, that is, a file already existing when the Project has not yet been run, a dotted line box represents a file generated during the running process of the Project, a thin frame long box represents an intermediate file, a short frame represents a folder, and a thick frame long box represents a source code file. In different application scenarios, the naming of each file can be different according to different actual requirements.
In the embodiment shown in fig. 3a, five folders may be included in the project, namely, data (data), in (input), out (output), share (share), and src (resource). Since the folders function to effectively manage files, only the function of the files in each folder will be described below. It should be understood that fig. 3a is only a schematic diagram of one possible engineering catalog structure of an engineering for detecting a migration program according to an embodiment of the present invention, and in other possible embodiments, files with different functions may be combined according to actual needs, or one file may be split into a plurality of files for implementing functions implemented by the one file according to actual needs, which is not limited in this embodiment.
target. Cl: a file for saving code of the migration program;
configuration.ini: a configuration file for configuring operation parameters of the verifiationproject runtime;
xls: a form file for presenting the function information to the user;
main. Cpp under in file: a cpp (c++) file for storing code of the verifiationproject main function;
makefile: script files for managing files in the verifiation project, such as for specifying the order in which the files are compiled, which files need to be recompiled, etc.;
cpu main. Cpp: the cpp file is used for storing the codes of the test cases in the CPU platform environment;
result. Txt: a text file for storing the test results;
functional name. Cl: the method comprises the steps of storing a command file of a packaged function obtained after kernel (kernel) packaging of a function to be detected;
main. Cpp under out/fpga/test/host/src folder: cpp file for saving code of test cases in fpga platform environment
DelareCPVar. Txt: the text file is used for storing the test vector under the CPU platform environment;
declarevar·txt: the text file is used for storing the test vector under the FPGA platform environment;
funcinfo. Txt: the text document for storing intermediate information may be referred to the above related description, and will not be described herein;
subfuncinfo. Txt: for the text document for storing the structural information, reference may be made to the foregoing related description, and the description is omitted herein.
findfincname. Py: the cl file is used for traversing the cl file under the in folder so as to acquire intermediate information of each function in the transplanting program;
findsubfunctions. Py: the method comprises the steps of obtaining structural information of each function in a migration program by combining intermediate information;
createdata.py: the method comprises the steps of reading intermediate information in subfunctioninfo.txt and generating data.xls;
readdata. Py: the method comprises the steps of reading data information in a data.xls file, generating test vectors, and storing the test vectors into DelarePuVar_ txt and DeclareVar_ txt respectively;
createCPUmain. Py: for generating a cpu main. Cpp from the function information of the band detection function and the return value of readdata. Py;
ModifyCL.py: the method comprises the steps of performing kernel encapsulation for a function to be detected in a transplanting program;
checkresult.py: the device is used for detecting whether the first test result and the second test result are the same or not and reporting the difference between the first test result and the second test result;
run. Py: for starting each py file;
util.py: the public function storage method is used for storing public functions, and the stored public functions can be different according to different actual requirements;
findsruct.py: for traversing the lookup structure in the migration procedure.
The working principle of the verifiation project will be described below, and reference may be made to fig. 3b, where fig. 3b is a schematic flow diagram of a method for detecting a migration program according to an embodiment of the present invention, and the method may include:
s301, traversing the target.cl file to generate funcinfo.txt containing information such as a function name, a function shape parameter, a line number of a starting line of the function in the target.cl file, a line number of an ending line of the function in the target.cl file, a line number of a line where the function name is located, a return type and the like.
S302, traversing target.cl again and depending on funcinfo.txt, obtaining a tree structure relation of function names according to the called parent-child node relation among functions, and storing the tree structure relation to the funcinfo.txt.
It can be understood that the function name, the line number of the start line and the line number of the end line of the function in the target.cl file are stored in the funcinfo.txt, so that when traversing the target.cl again, the relation of the call between the functions can be determined according to the information in the funcinfo.txt. For example, if the function named "a" has a line number of 101 for the beginning line and 105 for the ending line, and the function named "B" appears in line 103, it may be determined that the function named "B" is called in the function named "a".
S303, generating data. Xls according to the subfunctioninfo.
The meaning of the information in data. Xls may be the same as that of the information in subfunctioninfo. Txt, except for the form of the representation. The subfunctioninfo.txt is a text file in which information is represented in a text form, and the data.xls is a table file in which information is represented in a table form. The subfunctioninfo. Txt may be converted to data. Xls using a preset algorithm for converting text to a table.
S304, data. Xls is shown.
S305, acquiring a modification instruction input for the data. Xls, and modifying the data. Xls according to the modification instruction.
The developer can input a modification instruction through a program having an xls file editing function to modify the data. Xls file.
S306, generating a preset number of test cases according to the function information stored in the modified data. Xls.
Because these test cases need to be executed in the CPU platform environment and the FPGA platform environment, respectively, generating one test case may be generating two different versions of files, and by way of example, generating one test case may be generating one DeclareCpu. Where, is the identification of the file used to distinguish the different test cases, declarecpu_.txt is the file used to execute the test case in the CPU platform environment, declarevar_.txt is the file used to execute the test case in the FPGA platform environment.
Function names, function return types, function levels, shape parameters, shape parameter names, input/output types of shape parameters, array offsets, array length information can be obtained from data.xls by using readdata.py, and a specified number of test cases can be generated according to the read information.
S307, according to the function information of the function to be detected, generating a CPU main source program file of the function to be detected in the CPU platform environment and a main source program file of the function to be detected in the FPGA platform environment, integrating the target file, and packaging the function to be detected to generate a funcName file.
The function information may be read from data.xls in S306, and funcName represents a function name of the function to be detected. The information read from data.xls by readdata.py may be input to createCPUmain.py to generate a source program file cpuMain.cpp under the CPU platform environment using createCPUmain.py, and the information read from data.xls by readdata.py may be input to modyfin.py to generate a source program file main.cpp at host under the FPGA platform environment using modyfin.py. The method for generating the test case may be any test case generation method in the related art, and the embodiment is not limited thereto.
S308, compiling a CPU main. Cpp to obtain a first test program under the CPU platform, calling the first test program to execute DeclareCPU_txt to obtain a first test result, and storing the obtained first test result in a result. Txt file.
S309, compiling main.cpp and funcName.cl to obtain a second test program under the FPGa platform, calling the second test program to execute the unclary_txt to obtain a second test result, and storing the obtained second test result in a result.txt file.
It will be appreciated that S308 and S309 may be performed in parallel or alternatively.
S310, comparing the first test result and the second test result in the result.
The representation form of the comparison result may be different according to the application scenario, in a possible embodiment, if the first test result and the second test result of a function to be detected are different, the function name of the function to be detected, the line number of the start line, the line number of the end line, and the line number of the line where the function name is located in the target. The developer can quickly locate the functions with the anomalies in the target file by browsing the report.
For a clearer explanation of the working principle of the verifiation project provided by the embodiment of the present invention, refer to fig. 3c and fig. 3d, where fig. 3c is a schematic diagram of the verifiation project in the data preparation stage, and fig. 3d is a schematic diagram of the verifiation project in the function verification stage. The roles of the files can be referred to in the related description, and are not repeated here, the thick black line represents data transfer, and the thin black line represents compiling execution.
Referring to fig. 4, fig. 4 is a schematic structural diagram of a transplantation procedure detection apparatus according to an embodiment of the present invention, which may include:
a code parsing module 401, configured to parse a code of a migration program to obtain function information of a function to be detected included in the migration program;
a use case generating module 402, configured to generate, for each function to be detected, a test use case of the function to be detected according to the function information of the function to be detected, in order of preference of the function to be detected to the function to be detected;
the function test module 403 is configured to execute the test case under the original platform environment of the migration program by using the function to be detected to obtain a first test result, and execute the test case under the destination platform environment of the migration program by using the function to be detected to obtain a second test result;
A result comparison module 404, configured to compare whether the first test result and the second test result are the same;
and the conclusion output module 405 is configured to determine that the function to be detected is abnormal if the first test result and the second test result are different.
In a possible embodiment, the code parsing module 401 is specifically configured to traverse the code of the migration program, obtain, as the intermediate information of the function to be detected, one or more of the following information of the function to be detected included in the migration program:
the function name, the function adjacency parameter, the line number of the initial line of the function in the code, the line number of the final line of the function in the code and the return type;
traversing codes of the transplanting program, and determining calling relations between the function to be detected and other functions to be used as structural information of the function to be detected;
and taking the intermediate information and the structure information of the function to be detected as function information.
In a possible embodiment, the original platform of the migration program is a CPU platform, and the function test module 403 is specifically configured to generate, according to the function information, a source program file of the function to be detected under the CPU platform;
Compiling the source program file to generate a first test program under the CPU platform;
and calling the first test program to execute the test case to obtain a first test result.
In a possible embodiment, the destination platform of the migration program is a field programmable gate array FPGA platform, and the function test module 403 is specifically configured to encapsulate the function to be detected according to the code of the migration program, to obtain a command file;
compiling the command file to generate a second test program under the FPGA platform;
and calling the second test program to execute the test case to obtain a second test result.
In a possible embodiment, the code parsing module 401 is further configured to, before the generating, for each function to be detected, a test case of the function to be detected according to the function information of the function to be detected in sequence in preference to the order of relying on the function to be detected, construct a tree structure based on a dependency relationship between the functions to be detected, where each node in the tree structure corresponds to one function to be detected, and each node corresponds to a function to be detected, and depends on a function to be detected corresponding to a parent node of the node;
Traversing each node of the tree structure starting from a root node of the tree structure;
arranging each function to be detected according to the accessed sequence of the corresponding nodes when traversing the tree structure to obtain a function sequence to be detected;
the use case generating module 402 is specifically configured to generate, for each function to be detected in the sequence of functions to be detected, a test use case of the function to be detected according to the function information of the function to be detected.
In a possible embodiment, the result comparison module is specifically configured to compare whether the first test result and the second test result are the same, and includes:
comparing text contents in the first text file and the second text file;
if the text content in the first text file is the same as the text content in the second text file, determining that the first test result is the same as the second test result;
and if the text contents in the first text file and the second text file are different, determining that the first test result and the second test result are different.
The embodiment of the invention also provides an electronic device, as shown in fig. 5, which comprises a processor 501, a communication interface 502, a memory 503 and a communication bus 504, wherein the processor 501, the communication interface 502 and the memory 503 complete communication with each other through the communication bus 504,
A memory 503 for storing a computer program;
the processor 501 is configured to execute the program stored in the memory 503, and implement the following steps:
analyzing codes of a transplanting program to obtain function information of a function to be detected, which is included in the transplanting program;
according to the sequence that the depended function to be detected is higher than the depended function to be detected, aiming at each function to be detected in turn, generating a test case of the function to be detected according to the function information of the function to be detected;
executing the test case under the original platform environment of the migration program by using the function to be detected to obtain a first test result, and executing the test case under the target platform environment of the migration program by using the function to be detected to obtain a second test result;
comparing whether the first test result and the second test result are the same;
and if the first test result and the second test result are different, determining that the function to be detected is abnormal.
In a possible embodiment, after the parsing the code of the migration program to obtain the function information of the function to be detected included in the program to be detected, the method further includes:
Displaying the function information;
acquiring a modification instruction aiming at the function information input;
changing the function information according to the modification instruction to obtain changed function information;
the generating the test case of the function to be detected according to the function information comprises the following steps:
and generating the test case of the function to be detected according to the changed function information.
In a possible embodiment, the parsing the code of the migration program to obtain function information of the function to be detected included in the program to be detected includes:
traversing codes of a migration program, and acquiring one or more of the following information of a function to be detected, which is included in the migration program, as intermediate information of the function to be detected: the function name, the function adjacency parameter, the line number of the initial line of the function in the code, the line number of the final line of the function in the code and the return type;
traversing codes of the transplanting program, and determining calling relations between the function to be detected and other functions to be used as structural information of the function to be detected;
and taking the intermediate information and the structure information of the function to be detected as the function information.
In one possible embodiment, the original platform of the migration program is a CPU platform, and the executing the test case under the original platform environment of the migration program by using the function to be detected to obtain a first test result includes:
Generating a source program file of the function to be detected under the CPU platform according to the function information;
compiling the source program file to generate a first test program under the CPU platform;
and calling the first test program to execute the test case to obtain a first test result.
In one possible embodiment, the destination platform of the migration program is a field programmable gate array FPGA platform, and the executing the test case under the destination platform environment of the migration program by using the function to be detected to obtain the second test result includes:
according to the code of the transplanting program, the function to be detected is packaged, and a command file is obtained;
compiling the command file to generate a second test program under the FPGA platform;
and calling the second test program to execute the test case to obtain a second test result.
In one possible embodiment, before the step of generating, for each function to be detected, a test case of the function to be detected according to the function information of the function to be detected in order of the depended function to be detected in preference to the depended function to be detected, the method further includes:
Constructing a tree structure based on the dependency relationship among the functions to be detected, wherein each node in the tree structure corresponds to one function to be detected, and the function to be detected corresponding to each node depends on the function to be detected corresponding to the father node of the node;
traversing each node of the tree structure starting from a root node of the tree structure;
arranging each function to be detected according to the accessed sequence of the corresponding nodes when traversing the tree structure to obtain a function sequence to be detected;
the step of generating test cases of the function to be detected according to the function information of the function to be detected for each function to be detected in sequence in preference to the order of relying on the function to be detected according to the function to be detected, comprising:
and generating a test case of each function to be detected in the function sequence to be detected according to the function information of the function to be detected.
In one possible embodiment, the first test result is represented in the form of a first text file and the second test result is represented in the form of a second text file;
the comparing whether the first test result and the second test result are the same comprises:
Comparing text contents in the first text file and the second text file;
if the text content in the first text file is the same as the text content in the second text file, determining that the first test result is the same as the second test result;
and if the text contents in the first text file and the second text file are different, determining that the first test result and the second test result are different.
The communication bus mentioned above for the electronic devices may be a peripheral component interconnect standard (Peripheral Component Interconnect, PCI) bus or an extended industry standard architecture (Extended Industry Standard Architecture, EISA) bus, etc. The communication bus may be classified as an address bus, a data bus, a control bus, or the like. For ease of illustration, the figures are shown with only one bold line, but not with only one bus or one type of bus.
The communication interface is used for communication between the electronic device and other devices.
The Memory may include random access Memory (Random Access Memory, RAM) or may include Non-Volatile Memory (NVM), such as at least one disk Memory. Optionally, the memory may also be at least one memory device located remotely from the aforementioned processor.
The processor may be a general-purpose processor, including a central processing unit (Central Processing Unit, CPU), a network processor (Network Processor, NP), etc.; but also digital signal processors (Digital Signal Processing, DSP), application specific integrated circuits (Application Specific Integrated Circuit, ASIC), field programmable gate arrays (Field-Programmable Gate Array, FPGA) or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components.
In yet another embodiment of the present invention, a computer readable storage medium is provided, in which instructions are stored, which when run on a computer, cause the computer to perform any of the migration program detection methods of the above embodiments.
In yet another embodiment of the present invention, a computer program product containing instructions that, when run on a computer, cause the computer to perform any of the migration program detection methods of the above embodiments is also provided.
In the above embodiments, it may be implemented in whole or in part by software, hardware, firmware, or any combination thereof. When implemented in software, may be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions. When loaded and executed on a computer, produces a flow or function in accordance with embodiments of the present invention, in whole or in part. The computer may be a general purpose computer, a special purpose computer, a computer network, or other programmable apparatus. The computer instructions may be stored in or transmitted from one computer-readable storage medium to another, for example, by wired (e.g., coaxial cable, optical fiber, digital Subscriber Line (DSL)), or wireless (e.g., infrared, wireless, microwave, etc.). The computer readable storage medium may be any available medium that can be accessed by a computer or a data storage device such as a server, data center, etc. that contains an integration of one or more available media. The usable medium may be a magnetic medium (e.g., floppy Disk, hard Disk, magnetic tape), an optical medium (e.g., DVD), or a semiconductor medium (e.g., solid State Disk (SSD)), etc.
It is noted that relational terms such as first and second, and the like are 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. Moreover, 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 one … …" does not exclude the presence of other like elements in a process, method, article, or apparatus that comprises the element.
In this specification, each embodiment is described in a related manner, and identical and similar parts of each embodiment are all referred to each other, and each embodiment mainly describes differences from other embodiments. In particular, for the apparatus, electronic device, computer readable storage medium, and computer program product embodiments, the description is relatively simple, as relevant to the method embodiments being referred to in the section of the description of the method embodiments.
The foregoing description is only of the preferred embodiments of the present invention and is not intended to limit the scope of the present invention. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present invention are included in the protection scope of the present invention.
Claims (13)
1. A method of detecting a migration procedure, the method comprising:
analyzing codes of a transplanting program to obtain function information of a function to be detected, which is included in the transplanting program;
according to the sequence that the depended function to be detected is higher than the depended function to be detected, aiming at each function to be detected in turn, generating a test case of the function to be detected according to the function information of the function to be detected;
executing the test case under the CPU platform environment of the transplanting program by using the function to be detected to obtain a first test result, and executing the test case under the FPGA platform environment of the transplanting program by using the function to be detected to obtain a second test result;
comparing whether the first test result and the second test result are the same;
if the first test result and the second test result are different, determining that the function to be detected is abnormal;
Before the function to be detected is prioritized over the order of relying on the function to be detected, and each function to be detected is sequentially targeted to each function to be detected, and the test case of the function to be detected is generated according to the function information of the function to be detected, the method further comprises:
constructing a tree structure based on the dependency relationship among the functions to be detected, wherein each node in the tree structure corresponds to one function to be detected, and the function to be detected corresponding to each node depends on the function to be detected corresponding to the father node of the node;
traversing each node of the tree structure starting from a root node of the tree structure;
arranging each function to be detected according to the accessed sequence of the corresponding nodes when traversing the tree structure to obtain a function sequence to be detected;
the step of generating test cases of the function to be detected according to the function information of the function to be detected for each function to be detected in sequence in preference to the order of relying on the function to be detected according to the function to be detected, comprising:
and generating a test case of each function to be detected in the function sequence to be detected according to the function information of the function to be detected.
2. The method according to claim 1, wherein after the analyzing the code of the migration program to obtain the function information of the function to be detected included in the migration program, the method further comprises:
displaying the function information;
acquiring a modification instruction aiming at the function information input;
changing the function information according to the modification instruction to obtain changed function information;
the generating the test case of the function to be detected according to the function information comprises the following steps:
and generating the test case of the function to be detected according to the changed function information.
3. The method according to claim 1, wherein the parsing the code of the migration program to obtain the function information of the function to be detected included in the migration program includes:
traversing codes of a migration program, and acquiring one or more of the following information of a function to be detected, which is included in the migration program, as intermediate information of the function to be detected: the function name, the function adjacency parameter, the line number of the initial line of the function in the code, the line number of the final line of the function in the code and the return type;
traversing codes of the transplanting program, and determining calling relations between the function to be detected and other functions to be used as structural information of the function to be detected;
And taking the intermediate information and the structure information of the function to be detected as the function information.
4. The method of claim 1, wherein executing the test case in the CPU platform environment of the migration program using the function to be detected, to obtain a first test result, comprises:
generating a source program file of the function to be detected under the CPU platform according to the function information;
compiling the source program file to generate a first test program under the CPU platform;
and calling the first test program to execute the test case to obtain a first test result.
5. The method of claim 1, wherein the executing the test case in the FPGA platform environment of the grafted program using the function to be detected to obtain the second test result comprises:
according to the code of the transplanting program, the function to be detected is packaged, and a command file is obtained;
compiling the command file to generate a second test program under the FPGA platform;
and calling the second test program to execute the test case to obtain a second test result.
6. The method of claim 1, wherein the first test result is represented in the form of a first text file and the second test result is represented in the form of a second text file;
The comparing whether the first test result and the second test result are the same comprises:
comparing text contents in the first text file and the second text file;
if the text content in the first text file is the same as the text content in the second text file, determining that the first test result is the same as the second test result;
and if the text contents in the first text file and the second text file are different, determining that the first test result and the second test result are different.
7. A migration procedure detection apparatus, the apparatus comprising:
the code analysis module is used for analyzing the codes of the transplanting program to obtain the function information of the function to be detected, which is included in the transplanting program;
the use case generation module is used for generating test use cases of the function to be detected according to the function information of the function to be detected, aiming at each function to be detected in turn according to the order of the function to be detected which is depended over the function to be detected;
the function test module is used for executing the test case under the CPU platform environment of the transplanting program by utilizing the function to be detected to obtain a first test result, and executing the test case under the FPGA platform environment of the transplanting program by utilizing the function to be detected to obtain a second test result;
The result comparison module is used for comparing whether the first test result and the second test result are the same or not;
the conclusion output module is used for determining that the function to be detected is abnormal if the first test result and the second test result are different;
the code analysis module is further configured to, before generating a test case of the function to be detected according to the function information of the function to be detected, sequentially for each function to be detected according to the order in which the function to be detected depends on the function to be detected, construct a tree structure based on a dependency relationship between the functions to be detected, where each node in the tree structure corresponds to one function to be detected, and each node corresponds to the function to be detected, and depends on the function to be detected corresponding to a parent node of the node;
traversing each node of the tree structure starting from a root node of the tree structure;
arranging each function to be detected according to the accessed sequence of the corresponding nodes when traversing the tree structure to obtain a function sequence to be detected;
the use case generation module is specifically configured to generate, for each function to be detected in the sequence of functions to be detected, a test use case of the function to be detected according to the function information of the function to be detected.
8. The apparatus according to claim 7, wherein the code parsing module is specifically configured to traverse a code of a migration program, and obtain, as intermediate information of the function to be detected, one or more of the following information of the function to be detected included in the migration program:
the function name, the function adjacency parameter, the line number of the initial line of the function in the code, the line number of the final line of the function in the code and the return type;
traversing codes of the transplanting program, and determining calling relations between the function to be detected and other functions to be used as structural information of the function to be detected;
and taking the intermediate information and the structure information of the function to be detected as function information.
9. The device according to claim 7, wherein the function test module is specifically configured to generate a source program file of the function to be detected under a CPU platform according to the function information;
compiling the source program file to generate a first test program under the CPU platform;
and calling the first test program to execute the test case to obtain a first test result.
10. The apparatus of claim 7, wherein the function test module is specifically configured to encapsulate the function to be detected according to the code of the migration program to obtain a command file;
Compiling the command file to generate a second test program under the FPGA platform;
and calling the second test program to execute the test case to obtain a second test result.
11. The apparatus of claim 7, wherein the first test result is represented in the form of a first text file and the second test result is represented in the form of a second text file;
the result comparison module is specifically configured to compare whether the first test result and the second test result are the same, and includes:
comparing text contents in the first text file and the second text file;
if the text content in the first text file is the same as the text content in the second text file, determining that the first test result is the same as the second test result;
and if the text contents in the first text file and the second text file are different, determining that the first test result and the second test result are different.
12. The electronic equipment is characterized by comprising a processor, a communication interface, a memory and a communication bus, wherein the processor, the communication interface and the memory are communicated with each other through the communication bus;
A memory for storing a computer program;
a processor for carrying out the method steps of any one of claims 1-6 when executing a program stored on a memory.
13. A computer-readable storage medium, characterized in that the computer-readable storage medium has stored therein a computer program which, when executed by a processor, implements the method steps of any of claims 1-6.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010049678.4A CN111240987B (en) | 2020-01-16 | 2020-01-16 | Method and device for detecting migration program, electronic equipment and computer readable storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010049678.4A CN111240987B (en) | 2020-01-16 | 2020-01-16 | Method and device for detecting migration program, electronic equipment and computer readable storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111240987A CN111240987A (en) | 2020-06-05 |
| CN111240987B true CN111240987B (en) | 2024-03-08 |
Family
ID=70871059
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010049678.4A Active CN111240987B (en) | 2020-01-16 | 2020-01-16 | Method and device for detecting migration program, electronic equipment and computer readable storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111240987B (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111797009A (en) * | 2020-06-22 | 2020-10-20 | 北京字节跳动网络技术有限公司 | Method and device for detecting code compatibility and electronic equipment |
| CN111930617B (en) * | 2020-07-31 | 2023-08-25 | 中国工商银行股份有限公司 | Automatic test method and device based on data objectification |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103530132A (en) * | 2013-10-29 | 2014-01-22 | 浪潮电子信息产业股份有限公司 | Method for transplanting CPU (central processing unit) serial programs to MIC (microphone) platform |
| CN103729180A (en) * | 2013-12-25 | 2014-04-16 | 浪潮电子信息产业股份有限公司 | Method for quickly developing CUDA (compute unified device architecture) parallel programs |
| CN105700854A (en) * | 2014-11-25 | 2016-06-22 | 杭州海康威视数字技术股份有限公司 | Method and device for operating application task |
| CN109710508A (en) * | 2018-08-20 | 2019-05-03 | 平安普惠企业管理有限公司 | Test method, test device, test equipment and computer readable storage medium |
| CN110554965A (en) * | 2019-09-05 | 2019-12-10 | 腾讯科技（深圳）有限公司 | automated fuzz testing method, related equipment and computer readable storage medium |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20070011669A1 (en) * | 2005-07-06 | 2007-01-11 | International Business Machines Corporation | Software migration |
-
2020
- 2020-01-16 CN CN202010049678.4A patent/CN111240987B/en active Active
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103530132A (en) * | 2013-10-29 | 2014-01-22 | 浪潮电子信息产业股份有限公司 | Method for transplanting CPU (central processing unit) serial programs to MIC (microphone) platform |
| CN103729180A (en) * | 2013-12-25 | 2014-04-16 | 浪潮电子信息产业股份有限公司 | Method for quickly developing CUDA (compute unified device architecture) parallel programs |
| CN105700854A (en) * | 2014-11-25 | 2016-06-22 | 杭州海康威视数字技术股份有限公司 | Method and device for operating application task |
| CN109710508A (en) * | 2018-08-20 | 2019-05-03 | 平安普惠企业管理有限公司 | Test method, test device, test equipment and computer readable storage medium |
| CN110554965A (en) * | 2019-09-05 | 2019-12-10 | 腾讯科技（深圳）有限公司 | automated fuzz testing method, related equipment and computer readable storage medium |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111240987A (en) | 2020-06-05 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US11650905B2 (en) | Testing source code changes | |
| CN110083360B (en) | Compiling method, device, equipment and storage medium of application program code | |
| CN110795088B (en) | Front-end engineering project construction method and tool, and computer-readable storage medium | |
| US10514898B2 (en) | Method and system to develop, deploy, test, and manage platform-independent software | |
| US20140208297A1 (en) | Validation of revised computer programs | |
| CN111240987B (en) | Method and device for detecting migration program, electronic equipment and computer readable storage medium | |
| US11422917B2 (en) | Deriving software application dependency trees for white-box testing | |
| CN112860312A (en) | Method and device for detecting item dependency relationship change | |
| CN113495728A (en) | Dependency relationship determination method, dependency relationship determination device, electronic equipment and medium | |
| CN114780109A (en) | Python project third-party library dependence automatic analysis and installation method | |
| CN109284222B (en) | Software unit, project testing method, device and equipment in data processing system | |
| WO2023207973A1 (en) | Compiler test method and apparatus, case generation method and apparatus, and instruction storage structure | |
| CN116578282A (en) | Code generation method, device, electronic equipment and medium | |
| CN114816816A (en) | Collapse stack information processing method, device, equipment and storage medium | |
| CN114791884A (en) | Test environment construction method and device, storage medium and electronic equipment | |
| CN111367512B (en) | Method and device for creating Android library module dependency relationship in application development | |
| CN114115982A (en) | Code issuing method, device, equipment and storage medium | |
| CN114816984A (en) | JAVA program regression test method and test device | |
| CN114047923A (en) | Error code positioning method, device, storage medium and electronic equipment | |
| CN111273940B (en) | Method and device for uploading program file to code warehouse | |
| CN112965697A (en) | Code file generation method and device and electronic equipment | |
| CN110321138B (en) | Program updating and migration method and device | |
| CN110688430A (en) | Method and device for obtaining data bypass and electronic equipment | |
| CN110716746B (en) | Method and device for converting RN style code into applet style code | |
| CN112068814A (en) | Method, device, system and medium for generating executable file |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |