CN111831540A - Debugging information processing method, processing device and storage medium - Google Patents
Debugging information processing method, processing device and storage medium Download PDFInfo
- Publication number
- CN111831540A CN111831540A CN201910322010.XA CN201910322010A CN111831540A CN 111831540 A CN111831540 A CN 111831540A CN 201910322010 A CN201910322010 A CN 201910322010A CN 111831540 A CN111831540 A CN 111831540A
- Authority
- CN
- China
- Prior art keywords
- debugging
- information
- text information
- index table
- tool
- 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.)
- Withdrawn
Links
Images
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/362—Software debugging
- G06F11/3624—Software debugging by performing operations on the source code, e.g. via a compiler
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/90—Details of database functions independent of the retrieved data types
- G06F16/901—Indexing; Data structures therefor; Storage structures
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/90—Details of database functions independent of the retrieved data types
- G06F16/903—Querying
- G06F16/90335—Query processing
- G06F16/90348—Query processing by searching ordered data, e.g. alpha-numerically ordered data
Abstract
The application discloses a processing method, a processing device and a storage medium of debugging information, in particular to the method for acquiring the debugging information to be printed, wherein the debugging information comprises text information to be displayed on a debugging tool; generating a message code of each piece of debugging information according to the received debugging information, wherein the number of occupied bytes of the message code is smaller than that of the text information; creating an index table based on the message codes and the text information, and storing the index table; replacing text information with the message code, and compiling to output compiled debugging data; and sending the debugging data to a debugging tool so that the debugging tool converts the message codes in the debugging data into corresponding text information according to the corresponding relation in the synchronously acquired index table, and displaying the text information on the debugging tool. According to the embodiment of the application, the size of the debugging information is compressed, so that the processing overhead in the generation and transmission processes of the debugging information is reduced, and the debugging requirements of the multi-protocol stack are met.
Description
Technical Field
The present application relates to the field of communications technologies, and in particular, to a method, a device, and a storage medium for processing debug information.
Background
With the wide application of new technologies such as Long Term Evolution (LTE-G) in the power industry, more and more smart meters perform wireless data transmission through LTE-G terminals. At present, a processor of an LTE-G terminal used for an acquisition service (electric meter data acquisition and control) in the power industry is generally a low-power version with a low dominant frequency. Meanwhile, the communication interface is generally a 485 serial port or a 232 serial port, and the data transmission rate is generally below 100 kbps. The speed of the low-speed serial port is only 100kbps, the bandwidth needs to carry power acquisition service data of 36kbps, and the transmission bandwidth for software debugging is only 60 kbps. According to the LTE-G protocol standard, the calculation is carried out on one subframe in 25ms, and the capability of outputting debugging information needing debugging, namely the printing capability, of only 1500 bytes (capable of bearing 20 rows of debugging information) of each subframe is converted. The printing capability cannot meet the debugging requirements of a plurality of Protocol stacks such as a Non-access stratum (NAS), a Packet Data Convergence Protocol (PDCP), a Radio Link Control (RLC) and the like in the terminal. In addition, the low main frequency processor has limited processing capacity and low processing capacity, and the debugging data stream of 60kbps is additionally processed while the service flow rate of 36kbps is met, so that the processing capacity of the processor is high.
Therefore, low-cost terminals such as LTE-G terminals used by smart meters have severe requirements on power consumption, size, and cost of the terminals due to large number base and wide deployment. Software development is performed on the low-cost terminal, the processing capacity and the interface speed are severely limited, and the efficiency of outputting debugging information needing to be printed is low.
Disclosure of Invention
The embodiment of the application provides a debugging information processing method, and the method solves the problem that debugging information is difficult to print on a low-cost terminal by compressing the debugging information to be printed, reduces the debugging data flow rate while meeting debugging requirements, and improves the processing efficiency of a system.
The method comprises the following steps:
acquiring the debugging information to be printed, wherein the debugging information comprises text information to be displayed on a debugging tool;
generating a message code of each piece of debugging information according to the received debugging information, wherein the number of bytes occupied by the message code is smaller than that of the text information;
creating an index table based on the message codes and the text information, and storing the index table, wherein the message codes and the text information in the index table are in one-to-one correspondence;
replacing the text information with the message code, and compiling to output compiled debugging data;
and sending the debugging data to the debugging tool so that the debugging tool converts the message codes in the debugging data into corresponding text information according to the corresponding relation in the synchronously acquired index table, and displaying the text information on the debugging tool.
Optionally, the same text information in the index table is merged, and a message code corresponding to the merged text information is regenerated.
Optionally, before the first connection with the debugging tool and the debugging, the debugging tool synchronously acquires the stored index table.
Optionally, the debugging tool extracts the message code from the received debugging data, and queries the text information corresponding to the received message code in the synchronously obtained index table;
and determining the inquired text information as the debugging information needing to be printed.
In another embodiment of the present invention, there is provided a debugging information processing apparatus including:
the acquisition module is used for acquiring the debugging information to be printed, wherein the debugging information comprises text information to be displayed on a debugging tool;
the generating module is used for generating a message code of each piece of debugging information according to the received debugging information, and the number of occupied bytes of the message code is smaller than that of the text information;
the building module is used for creating an index table based on the message codes and the text information and storing the index table, wherein the message codes and the text information in the index table are in one-to-one correspondence;
the replacing module is used for replacing the text information by using the message code, compiling the text information and outputting compiled debugging data;
and the conversion module is used for sending the debugging data to the debugging tool so that the debugging tool converts the message codes in the debugging data into the corresponding text information according to the corresponding relation in the synchronously acquired index table and displays the text information on the debugging tool.
Optionally, the processing apparatus further comprises:
and the merging module is used for merging the same text information in the index table and regenerating a message code corresponding to the merged text information.
Optionally, the processing apparatus further comprises:
and the synchronization module is used for synchronously acquiring the stored index table by the debugging tool before the debugging tool is connected with the debugging tool for the first time and debugs.
Optionally, the conversion module comprises:
the query unit is used for the debugging tool to extract the message code from the received debugging data and query the text information corresponding to the received message code in the synchronously acquired index table;
and the determining unit is used for determining the inquired text information as the debugging information needing to be printed.
In another embodiment of the present invention, there is provided a non-transitory computer readable storage medium storing instructions that, when executed by a processor, cause the processor to perform the steps of one of the above-described methods of processing debugging information.
In another embodiment of the present invention, a terminal device is provided, which includes a processor, and the processor is configured to execute the steps in the processing method of the debugging information.
As can be seen from the above, based on the above embodiment, firstly, the debugging information to be printed is acquired, where the debugging information includes text information to be displayed on the debugging tool, and secondly, the message code of each piece of debugging information is generated according to the received debugging information, and the number of occupied bytes of the message code is smaller than that of the text information. And meanwhile, based on the message codes and the text information, creating an index table, storing the index table, wherein the message codes and the text information in the index table are in one-to-one correspondence, then replacing the text information with the message codes, compiling to output compiled debugging data, and finally sending the debugging data to a debugging tool so that the debugging tool converts the message codes in the debugging data into corresponding text information according to the correspondence in the synchronously acquired index table, and displaying the text information on the debugging tool. According to the method and the device, the text information in the debugging information to be printed is replaced by the message code with the smaller byte number, the debugging information to be printed is compressed, the text information and the message code are correspondingly generated into the index table, and the text information is correspondingly displayed on the debugging tool according to the index table, so that the processing overhead in the debugging information generation and transmission process is reduced, and the processing efficiency of the system is improved.
Drawings
In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings that are required to be used in the embodiments will be briefly described below, it should be understood that the following drawings only illustrate some embodiments of the present application and therefore should not be considered as limiting the scope, and for those skilled in the art, other related drawings can be obtained from the drawings without inventive effort.
Fig. 1 is a schematic flowchart illustrating a method for processing debug information according to embodiment 10 of the present application;
fig. 2 is a schematic diagram illustrating a specific flow of a method for processing debug information in embodiment 20 provided in the present application;
fig. 3 is a schematic diagram illustrating a device for processing debug information according to embodiment 30 of the present application;
fig. 4 shows a schematic diagram of a terminal device provided in embodiment 40 of the present application.
Detailed Description
In order to make the objects, technical solutions and advantages of the present invention more apparent, the present invention is further described in detail below with reference to the accompanying drawings and examples.
Based on the problems in the prior art, the embodiments of the present application provide a method for processing debug information, which combines the characteristic that the debug information of an electric power wireless private network terminal is generally whole-line text information, allocates a message code of 4 bytes to each piece of printed debug information according to a statement line number and a character string feature code of the text information to be printed, and generates an index table in which the message code corresponds to the text information. When the private network terminal works, the output of the debugging information which is traditionally expressed as the whole line of text information is converted into an output message code. And then, on the corresponding debugging tool, calling the corresponding index table to restore the message codes into text information for debugging and testing of research personnel.
The application field of the application is mainly in the technical field of communication and is applicable to the power application technology. Fig. 1 is a schematic flowchart of a method for processing debug information according to embodiment 10 of the present application. The detailed steps are as follows:
and S11, acquiring debugging information needing to be printed.
In this step, the debugging information is mainly selected from the compiler and assembler options to provide various information required for debugging the application code. The debugging information to be printed in the private network terminal is generated by the output statement to be printed in the code, and the debugging information comprises text information to be displayed on a debugging tool. The following output statements to be printed exist as code: log _ String _ Printf ("Current Period received DCI right | Sfn ═ d, periodNum |% d", gSfn, gperiodNum). For the debug information, the text information of the debug information actually output to the debug tool is "Current periodic receive DCRight! Sfn is 0000, periodNum is 0000 ". The output of the whole printed debugging information is 58 characters, and 58 bytes are occupied.
In addition, after the compiler compiles the debugging information to be printed, if the debugging information is a Log _ Printf statement, the text information of the piece of debugging information is acquired.
S12, a message code for each piece of debug information is generated based on the received debug information.
In this step, after the debug information to be printed is received, a message code is generated for each piece of debug information according to the receiving order of the debug information. For example, a sequence number is created for each piece of recorded debug information, and one is sequentially added to the sequence number, so that each piece of debug information corresponds to a different message code. In addition, other ways of determining the message code for each piece of debug information may also be used. The number of occupied bytes of the message code is smaller than that of the text information. As described above, the number of bytes occupied by the text message in step S11 is 58 bytes, and if the message code allocated for the debug information is 219, the number of bytes occupied by the message code is much smaller than the number of bytes occupied by the text message.
S13, creating an index table based on the message code and the text information, and saving the index table.
In this step, each piece of debugging information corresponds to one message code. Meanwhile, a one-to-one correspondence relationship is established between the message code and the text information of the corresponding debugging information, and an index table is created according to the message code and the corresponding text information. The message codes and the text information in the index table are in one-to-one correspondence. And recording the message code and text information of each piece of debugging information in the index table. After the index table is created, the index table is stored in a storage chip such as FLASH of the private network terminal.
And S14, replacing the text information with the message code and compiling to output the compiled debugging data.
In this step, when compiling is performed, the message code is used to replace the text information in each piece of debugging information to be printed, where as in the above example, the serial number assigned to the debugging information to be printed is 219, and the corresponding message code is 219. At this time, the code entering the compiler is: log _ Code _ Printf (219, gSfn, g period num), the corresponding actual output debug data is: "219,0000,0000", the output debug data is 12 bytes.
And S15, sending the debugging data to the debugging tool, so that the debugging tool converts the message codes in the debugging data into corresponding text information according to the corresponding relation in the synchronously acquired index table, and displaying the text information on the debugging tool.
In this step, the debugging tool is an interface, a log or a browser capable of displaying debugging information. After the private network terminal sends the debugging data to the debugging tool, the debugging tool recovers the received debugging data. Specifically, after the debugging tool receives the debugging data, the index table stored in the private network terminal is synchronously acquired. Meanwhile, according to the message codes in the received debugging data, text information of corresponding debugging information is inquired in the obtained index table, and the text information corresponding to the received message codes is displayed on a debugging tool for debugging by debugging personnel.
Based on the above embodiment of the present application, firstly, debugging information to be printed is obtained, where the debugging information includes text information to be displayed on a debugging tool, secondly, a message code of each piece of debugging information is generated according to the received debugging information, meanwhile, an index table is created based on the message code and the text information, and the index table is stored, where the message code and the text information included in the index table correspond to each other one by one, then, the text information in the debugging information is replaced with the message code, and compiled to output compiled debugging data, and finally, the debugging data is sent to the debugging tool, so that the debugging tool converts the debugging data into text information corresponding to the message code in the debugging data according to a corresponding relationship in the index table, and displays the text information on the debugging tool. The embodiment of the application compresses the debugging information and generates the corresponding index table. Based on the example in embodiment 10, after the index table is used, the output single piece of debugging information is reduced from 58 bytes to 12 bytes, the compression rate reaches 20%, and the whole process does not use any compression algorithm, only uses one table lookup operation, and has extremely high processing efficiency. Meanwhile, processing overhead in the process of generating and transmitting debugging information is reduced, and the debugging requirement of the multi-protocol stack is met.
Fig. 2 is a schematic diagram of a specific flow of a method for processing debug information in embodiment 20 provided by the present application. Wherein, the detailed process of the specific flow is as follows:
s201, debugging information needing to be printed is acquired.
S202, the pre-compiler analyzes the debugging information, generates a message code and creates an index table.
Here, the flow of converting the debugging information to be printed into the message code and generating the index table is completed by the pre-set and compiler. Specifically, the pre-compiler mainly performs various operations such as counting debugging information to be printed, generating an index table, and matching a debugging tool with the index table. In the pre-compiling process, before formal compiling, a pre-compiler is added, which mainly analyzes debugging information needing to be printed in codes, generates an index table and replaces text information in the original debugging information according to message codes.
S203, combining the message codes corresponding to the repeated text information in the index table.
Here, the same text information in the index table is merged, and a message code corresponding to the merged text information is regenerated. Specifically, according to the precompilation process, debugging information to be printed is sequentially processed to generate an index table, which may cause repeated text information to correspond to different message codes. If different message codes are generated for the same debugging information at different code positions, more repeated information may exist in the index table at this time, which reduces the processing efficiency and occupies more storage space of the private network terminal.
After the index table is completely generated, the repeated text information is merged to reduce the length of the index table. Since software development is performed cooperatively by different engineers, there may be slight differences in the same meaning of textual information, such as upper case and space. Therefore, the same printing parameter items are used for the same text information in the process of merging the repeated text information, wherein the printing parameter items are variables to be printed, such as two parameters of gSfn and gperiodNum in the example code. Meanwhile, the number of characters and the appearance sequence of the characters in the same text information are certain the same. In the process of counting the blank spaces and Tab, counting the number of characters is not counted. In addition, the upper and lower case characters are identified as the same character in the statistical process. The repeated text information in the index table is merged in the above way to reduce the volume of the index table.
S204, storing an index table.
Here, the software package file structure of the private network terminal is adjusted, and the storage area for storing the index table data is increased.
And S205, replacing the corresponding text information by the generated message code, and compiling.
Here, code compilation is performed to generate an executable file with a suffix name of.bin storing the compiled result.
And S206, packaging the software version.
In this step, the compiled executable file and data such as the index table are packaged to generate a version file of the private network terminal. Meanwhile, the index table generated by the pre-compiler is automatically compressed into the terminal software package by the version packaging script. At this time, the index table is compressed and then embedded into the version file.
And S207, synchronizing the index table.
In this step, before the first connection with the debugging tool and the debugging, the debugging tool synchronously acquires the stored index table. Specifically, when the debugging tool is connected with the private network terminal for the first time, the index table is extracted from the private network terminal version file through the index table synchronization process. And when the debugging tool is connected with the private network terminal, an index table synchronization flow is added. And sending a synchronization request to the private network terminal by the debugging tool, and randomly sending a synchronization response by the private network terminal and carrying index table data.
And S208, outputting the debugging information on the debugging tool.
In this step, the debugging tool extracts the message code from the received debugging data, and queries the text information corresponding to the received message code in the index table. Then, the inquired text information is determined as debugging information needing to be printed. Specifically, the debugging tool uses an index table matched with the software version to analyze debugging information.
The embodiment of the application realizes a method for processing debugging information based on the steps. In the version compiling process, the generated index table is compressed and then is implanted into the version file. In the debugging process, the debugging tool firstly performs the synchronous flow of the index table with the private network terminal, and after the index table is extracted from the private network terminal, the debugging tool analyzes the debugging information of the terminal by using the index table and then starts debugging and printing. In addition, the design of the pre-compiler is more convenient for maintenance, and the condition that the wrong debugging information is used possibly caused after the wrong index table is called can be prevented. When the private network terminal works, the traditional whole line of text information is output, and the message code is output instead. And on the debugging tool, restoring the message codes into text information by using the corresponding index table for debugging and testing by research and development personnel. The processing method in the embodiment of the application can compress the debugging information to 15% -25% of the original volume, reduces the processing overhead in the generation and transmission processes of the debugging information, and meets the debugging requirements of the multi-protocol stack. In the whole edition compiling, releasing, debugging and printing process, research personnel do not need to sense the existence of the index table, the maintenance cost is reduced, and the system reliability is improved.
Based on the same inventive concept, embodiment 30 of the present application further provides a schematic diagram of a device for processing debug information. As shown in fig. 3, wherein the apparatus comprises:
an obtaining module 31, configured to obtain debugging information to be printed, where the debugging information includes text information to be displayed on a debugging tool;
a generating module 32, configured to generate a message code of each piece of debugging information according to the received debugging information, where the number of bytes occupied by the message code is smaller than the number of bytes occupied by the text information;
the building module 33 is configured to create an index table based on the message codes and the text information, and store the index table, where the message codes and the text information in the index table correspond to each other one to one;
a replacing module 34, configured to replace the text information with the message code, and perform compiling to output compiled debugging data;
the conversion module 35 is configured to send the debugging data to the debugging tool, so that the debugging tool converts the message code in the debugging data into corresponding text information according to the correspondence in the synchronously obtained index table, and displays the text information on the debugging tool.
In this embodiment, specific functions and interaction manners of the obtaining module 31, the generating module 32, the constructing module 33, the replacing module 34, and the converting module 35 may refer to the description of the embodiment corresponding to fig. 1, and are not described herein again.
Optionally, the processing apparatus further comprises:
and the merging module 36 is configured to merge the same text information in the index table, and regenerate a message code corresponding to the merged text information.
Optionally, the processing apparatus further comprises:
and a synchronization module 37, configured to, before performing a first connection with the debugging tool and performing debugging, synchronize the debugging tool with the stored index table.
Optionally, the conversion module 35 comprises:
the query unit is used for extracting the message codes from the received debugging data by the debugging tool and querying the text information corresponding to the received message codes in the synchronously acquired index table;
and the determining unit is used for determining the inquired text information as debugging information needing to be printed.
As shown in fig. 4, another embodiment 40 of the present application further provides a terminal device, which includes a processor 40, where the processor 40 is configured to execute each step in the foregoing processing method for debugging information.
As can also be seen from fig. 4, the terminal device provided in the foregoing embodiment further includes a non-transitory computer readable storage medium 41, where the non-transitory computer readable storage medium 41 stores thereon a computer program, and the computer program is executed by the processor 40 to perform the steps in the above-described processing method for debugging information.
Specifically, the storage medium can be a general-purpose storage medium, such as a removable disk, a hard disk, a FLASH, and the like, and when the computer program on the storage medium is executed, the computer program can execute the steps in the debugging information processing method.
Finally, it should be noted that: the above-mentioned embodiments are only specific embodiments of the present application, and are used for illustrating the technical solutions of the present application, but not limiting the same, and the scope of the present application is not limited thereto, and although the present application is described in detail with reference to the foregoing embodiments, those skilled in the art should understand that: any person skilled in the art can modify or easily conceive the technical solutions described in the foregoing embodiments or equivalent substitutes for some technical features within the technical scope disclosed in the present application; such modifications, changes or substitutions do not depart from the spirit and scope of the exemplary embodiments of the present application, and are intended to be covered by the scope of the present application. Therefore, the protection scope of the present application shall be subject to the protection scope of the claims.
Claims (10)
1. A method for processing debugging information is characterized by comprising the following steps:
acquiring the debugging information to be printed, wherein the debugging information comprises text information to be displayed on a debugging tool;
generating a message code of each piece of debugging information according to the received debugging information, wherein the number of bytes occupied by the message code is smaller than that of the text information;
creating an index table based on the message codes and the text information, and storing the index table, wherein the message codes and the text information in the index table are in one-to-one correspondence;
replacing the text information with the message code, and compiling to output compiled debugging data;
and sending the debugging data to the debugging tool so that the debugging tool converts the message codes in the debugging data into corresponding text information according to the corresponding relation in the synchronously acquired index table, and displaying the text information on the debugging tool.
2. The process of claim 1, wherein between the step of creating an index table and the step of saving an index table, the process further comprises:
and merging the same text information in the index table, and regenerating a message code corresponding to the merged text information.
3. The processing method according to claim 2, wherein between the step of outputting compiled debug data and the step of sending debug data to the debug tool, the processing method further comprises:
and before the first connection with the debugging tool and the debugging, the debugging tool synchronously acquires the stored index table.
4. The processing method according to claim 3, wherein the step of the debugging tool converting the message code in the debugging data into the corresponding text message according to the correspondence in the index table obtained synchronously comprises:
the debugging tool extracts the message code from the received debugging data and inquires the text information corresponding to the received message code in the synchronously acquired index table;
and determining the inquired text information as the debugging information needing to be printed.
5. An apparatus for processing debug information, comprising:
the acquisition module is used for acquiring the debugging information to be printed, wherein the debugging information comprises text information to be displayed on a debugging tool;
the generating module is used for generating a message code of each piece of debugging information according to the received debugging information, and the number of occupied bytes of the message code is smaller than that of the text information;
the building module is used for creating an index table based on the message codes and the text information and storing the index table, wherein the message codes and the text information in the index table are in one-to-one correspondence;
the replacing module is used for replacing the text information by using the message code, compiling the text information and outputting compiled debugging data;
and the conversion module is used for sending the debugging data to the debugging tool so that the debugging tool converts the message codes in the debugging data into the corresponding text information according to the corresponding relation in the synchronously acquired index table and displays the text information on the debugging tool.
6. The processing apparatus according to claim 5, characterized in that the processing apparatus further comprises:
and the merging module is used for merging the same text information in the index table and regenerating a message code corresponding to the merged text information.
7. The processing apparatus according to claim 6, characterized in that the processing apparatus further comprises:
and the synchronization module is used for synchronously acquiring the stored index table by the debugging tool before the debugging tool is connected with the debugging tool for the first time and debugs.
8. The processing apparatus of claim 7, wherein the conversion module comprises:
the query unit is used for the debugging tool to extract the message code from the received debugging data and query the text information corresponding to the received message code in the synchronously acquired index table;
and the determining unit is used for determining the inquired text information as the debugging information needing to be printed.
9. A non-transitory computer readable storage medium storing instructions which, when executed by a processor, cause the processor to perform the steps of a method of processing debugging information as set forth in any one of claims 1 to 4.
10. A terminal device, characterized by comprising a processor for executing the steps of a method for processing debugging information according to any one of claims 1 to 4.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910322010.XA CN111831540A (en) | 2019-04-22 | 2019-04-22 | Debugging information processing method, processing device and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910322010.XA CN111831540A (en) | 2019-04-22 | 2019-04-22 | Debugging information processing method, processing device and storage medium |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN111831540A true CN111831540A (en) | 2020-10-27 |
Family
ID=72912771
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910322010.XA Withdrawn CN111831540A (en) | 2019-04-22 | 2019-04-22 | Debugging information processing method, processing device and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111831540A (en) |
Cited By (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113722236A (en) * | 2021-09-18 | 2021-11-30 | 网易（杭州）网络有限公司 | Game debugging method, device, equipment, storage medium and program product |
| CN114063943A (en) * | 2021-11-18 | 2022-02-18 | 芯翼信息科技(上海)有限公司 | Data transmission system, method, device, medium, and apparatus |
| CN115794614A (en) * | 2022-11-04 | 2023-03-14 | 摩尔线程智能科技(北京)有限责任公司 | Software debugging method and device, electronic equipment and storage medium |
-
2019
- 2019-04-22 CN CN201910322010.XA patent/CN111831540A/en not_active Withdrawn
Cited By (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113722236A (en) * | 2021-09-18 | 2021-11-30 | 网易（杭州）网络有限公司 | Game debugging method, device, equipment, storage medium and program product |
| CN113722236B (en) * | 2021-09-18 | 2023-08-08 | 网易（杭州）网络有限公司 | Game debugging method, device, equipment and storage medium |
| CN114063943A (en) * | 2021-11-18 | 2022-02-18 | 芯翼信息科技(上海)有限公司 | Data transmission system, method, device, medium, and apparatus |
| CN115794614A (en) * | 2022-11-04 | 2023-03-14 | 摩尔线程智能科技(北京)有限责任公司 | Software debugging method and device, electronic equipment and storage medium |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN111831540A (en) | Debugging information processing method, processing device and storage medium | |
| CN106936441B (en) | Data compression method and device | |
| KR101745456B1 (en) | Ecu for transmitting large data in hil test environment, system including the same and method thereof | |
| CN109032909A (en) | Processing method, system, equipment and the storage medium of application crash log | |
| CN111970353A (en) | Data processing method and device for heterogeneous equipment in Internet of things of cloud computing platform | |
| CN111294235B (en) | Data processing method, device, gateway and readable storage medium | |
| CN110535846B (en) | Data frame compression method and system based on DL/T698.45 protocol | |
| CN111683066A (en) | Heterogeneous system integration method and device, computer equipment and storage medium | |
| CN104219298A (en) | Cluster system and data backup method thereof | |
| CN111163043A (en) | Deep analysis method and system for real-time interactive protocol of source-network-load system | |
| CN111865952B (en) | Data processing method, data processing device, storage medium and electronic equipment | |
| CN111858113A (en) | Application program repairing method, device, service system and storage medium | |
| CN116755844A (en) | Data processing method, device and equipment of simulation engine and storage medium | |
| CN106033448A (en) | Method and device for compressing Html page | |
| CN103020157A (en) | High-reliability real-time file generation method spanning physical isolation | |
| CN105262491A (en) | Data compression method, data compression system, data decompression method, data decompression system and communication equipment | |
| CN108460044B (en) | Data processing method and device | |
| CN104636432B (en) | A kind of method and device of journal file compression and decompression | |
| CN110825538A (en) | MQ-based method for dynamically interacting data by self-defining data types | |
| US9065789B2 (en) | Remote communication method | |
| CN112416557B (en) | Method and device for determining call relation, storage medium and electronic device | |
| CN114741057A (en) | Train control network data frame protocol analysis method | |
| CN112335203B (en) | Processing local area network diagnostic data | |
| CN110247666B (en) | System and method for hardware parallel compression | |
| CN103246671A (en) | Processing method and device for abstract syntax notation files |
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 | ||
| WW01 | Invention patent application withdrawn after publication |
Application publication date: 20201027 |
|
| WW01 | Invention patent application withdrawn after publication |