The need for low resource computing devices continues to expand in both industry and consumer applications. Examples of such low resource computing devices include a set top box suitable for satellite or cable television reception, a video game console, a Personal Digital Assistant (PDA), a cellular telephone, and a handheld computing device. Developing software that is to be executed on a low resource computing device is best done on a high resource computing device. The robust memory and processing capabilities of the high resource computing device are conveniences available to a developer that can be used to emulate software being developed and debugged to run on the low resource computing device. For instance, the high resource computing device can execute an emulating application that can emulate the operation of a processor executing an application using an operating system in a low resource computing device. As such, the low resource computing device that is to be emulated will typically be a client that has less memory and/or computing resources than that of a computing device that is used to emulate the client executing applications that run on the client.
A typical software bug that occurs in applications developed on any computing device is a memory management bug. Memory management bugs are a key contributor to software instability and increased software development time for computing devices due to the effects of using an obsolete memory pointer in an incorrect access to memory. When an access to memory occurs during the execution of an application, and that access uses an obsolete pointer to memory, the application typically does not stop executing as soon as the incorrect memory access occurs. Rather, the result of this bug is not noticed until long after the incorrect memory access has occurred. As a result, a developer must undertake the often difficult task of finding how and where the bug occurred during execution of the application that performed the access to memory.
A typical example of a memory error occurs when a pointer to a portion of memory is used in a memory management operation after that portion had been previously freed by a prior memory management operation. In this example, the later memory management operation has re-referenced an obsolete memory pointer in an incorrect access to memory without any error being signaled. It would be an advance in the art to signal the occurrence of the incorrect memory access to memory at the time of its occurrence during the execution of emulation code so that the location of the errant code can be can easily identified—thereby increasing the probability of having an easily reproducible test case that can be used in debugging by a software developer.
USPTO Backgrounds
USPTO Backgrounds