Methods and apparatus for debugging software including divisions of an execution history of a debuggee program
View Patent ↗In a computing system environment, methods and architecture relate to debugging software programs. The programs, regardless of size, are culled for substantially all memory and register writes (and flow control). An indexing and compression occurs so that upon a later query, and decompression (and display), a user can find and diagnose defects in the software program. To efficiently reconstruct the contents of any memory location or register, backwards tracing of events is comprehensively known for all time, not just select periods. Efficiencies in the indexing function include bunching, replacing actual memory locations with pattern(s) representative of same and dividing an execution history of the software program into manageable sections. Nuances for memory or register effects are also contemplated. Still other embodiments contemplate stand-alone computer program products (on computer-readable media or as a download, or other) or those working in conjunction with other debugging programs.
1. In a computing environment, a method of debugging a software program regardless of a size of the software program, comprising:
obtaining a debuggee program;
without user input, determining all memory and register writes in the debuggee program regardless of when each said memory or register write occurred;
indexing the all memory and register writes;
compressing the indexed all memory and register writes so that upon later decompression the user can diagnose defects in the debuggee program; and
dividing an execution history of executable instructions of the debuggee program into discrete sections before the compressing, the discrete sections being arrayed together non-sequentially according to a number of instructions executed in the debuggee program wherein, at a beginning of each said discrete section, a content of all registers is recorded.
2. The method of claim 1 , further including recording all instructions executed in the debuggee program before the determining all memory and register writes.
3. The method of claim 1 , wherein the compressing further includes observing patterns in contiguous memory locations and replacing the memory locations with the observed pattern, the compressing including compression of the pattern.
4. The method of claim 1 , further including querying the compressed index of all memory and register writes.
5. The method of claim 4 , further including displaying a time-ordered result of the querying including displaying the all memory and register writes regardless of when each said write occurred.
6. A computer program product on a computer readable media having computer-executable instructions for performing the determining, indexing and compressing steps recited in claim 1 .
7. The method of claim 1 , further including bunching together contiguous memory locations before the compressing.
8. In a computing environment, an architecture on a first computing device for debugging a software program on said first computing device or another computing device in communication with the first computing device regardless of a size of the software program, the architecture comprising:
an instrumentation engine to cull all memory and register writes from the software program, without user input, regardless of when each of said memory or register write occurred;
an indexer process to receive and order an arrangement of the culled all memory and register writes from the instrumentation engine for compression into a log, said indexer process including a component to divide an execution history of the software program into discrete sections before compressing, the discrete sections being arrayed together non-sequentially according to a number of instructions executed in the software program; and
a query engine in communication with the log to obtain a decompressed version of the culled all memory and register writes so the user can diagnose defects in the software program.
9. The architecture of claim 8 , further including another software program for interfacing with the instrumentation engine to cull the all memory and register writes from the software program.
10. The architecture of claim 8 , wherein the indexer process further includes another component to examine contiguous memory locations written to by the software program and replace the memory locations with a pattern that becomes compressed.
11. The architecture of claim 8 , wherein the component for dividing the execution history of the software program into discrete sections records a content of all registers at a beginning of each said discrete section.
12. The architecture of claim 8 , wherein the indexer process further includes another component to bunch together contiguous memory locations before the compressing, the another component is configured to replace multiple same memory effects in the contiguous locations with a single memory effect representing said multiple same memory effects.
13. In a computing environment, an architecture on a first computing device for debugging a software program on said first computing device or another computing device in communication with the first computing device regardless of a size of the software program, the architecture comprising:
an instrumentation engine to cull all memory and register writes from the software program, without user input, regardless of when each of said memory or register write occurred, further including an interface with another software program useful in debugging the software program;
an indexer process to receive and order arrangement of the culled all memory and register writes from the instrumentation engine for compression into a log, the indexer process including: a first component to examine contiguous memory locations written to by the software program and replace the memory locations with a pattern that becomes compressed, a second component to divide an execution history of the software program into discrete sections that are arrayed together non-consecutively before compression, and a third component to bunch together contiguous memory locations before the compressing; and
a query engine in communication with the log to obtain a decompressed version of the culled all memory and register writes so the user can diagnose defects in the software program at a time after the query.
14. In a computing environment, a method of debugging a software program regardless of a size of the software program, comprising:
obtaining a debuggee program;
recording all instructions executed in the debuggee program;
thereafter, without user input, determining all memory and register writes in the debuggee program regardless of when each said memory or register write occurred;
indexing the all memory and register writes, including dividing the instructions executed into discrete sections that are arrayed together non-consecutively and bunching together contiguous memory locations;
compressing the indexed all memory and register writes including compressing the bunches of contiguous memory locations written to by the debuggee program;
querying the compressed index;
decompressing the compressed index; and
causing display of the decompressed compressed index so that the user can diagnose defects in the debuggee program, including displaying a time-ordered result of the all memory and register writes.
15. A computer program product on a computer readable media having computer-executable instructions for installation on a computing device for debugging a software program on or in communication with the computing device, comprising:
a first component to cull all memory and register writes from the software program, without user input, regardless of when each of said memory or register writes occurred;
a second component to receive and compress the culled all memory and register writes from the first component;
a third component in communication with the second component to obtain a decompressed version of the compressed culled all memory and register writes; and
a fourth component to cause display of the decompressed version on a monitor of the computing device so the user can diagnose defects in the software program,
wherein the second component is further configured to divide an execution history of the software program into discrete sections that are arrayed together non-sequentially before the compressing.
16. The computer program product of claim 15 , further including a fifth component for interacting with another software program useful in debugging the software program in order to cull the all memory and register writes.
17. The computer program product of claim 15 , wherein one of the components further includes an ability to examine contiguous memory locations written to by the software program and replace the contiguous memory locations with a single pattern that becomes compressed by the second component as part of the culled all memory and register writes.
18. The computer program product of claim 15 , wherein one of the components further includes a bunching function for contiguous memory locations before the compressing.