Abstract: An information processing and method include acquiring a trace group indicating instants of time of execution of processing operations and vestiges of contents of the execution, behavior information indicating behaviors of a processor of the arbitrary system, and state information indicating state transitions of an arbitrary hardware device other than the processor. A behavior trace searching unit searches when an arbitrary behavior is specified from behaviors indicated by the behavior information, a state trace searching unit searches when an arbitrary state transition is specified from the state transition indicated by the state information, an associating unit associates, the traces found by the behavior trace searching unit and the traces found by the state trace searching unit according to an instruction and an outputting unit outputs the traces associated by the associating unit as traces for a simulation of the behaviors.

Abstract: A method for detecting program code errors including searching for lines of command codes in the program code. A line of command code includes command codes and indices. The lines of command codes are organized as paragraphs. At least one of the lines of commands codes in each paragraph is different from the other lines of commands codes in the paragraph. The method further including separating the command codes from the indices for the lines of command codes, wherein the indices are a matrix of indices, and each row of indices in the matrix of indices includes the sets of indices for each of the lines of command codes from one of the paragraphs; determining each set of vertical indices in the matrix of indices that does not match a known series; and reporting to a user computer each set of vertical indices that does not match the known series.

Abstract: An approach for enabling maintenance of a test bed for use in executing software testing is described. A test management platform collects production data relating to execution of a prior release of an application within a production environment. The test management platform extracts unique messages from the collected production data to create a test bed including a plurality of test cases. Input messages to be processed by the application are generated based on a determination of which unique messages require a change based on a current release of the application.

Abstract: An automated system randomly generates test cases for hardware or software quality assurance testing. A test case comprises a sequence of discrete, atomic steps (or “building blocks”). A particular test case has a variable number of building blocks. The system takes a set of test actions and links them together to create a much larger library of test cases or “chains.” The chains comprise a large number of random sequence tests that facilitate “chaos-like” or exploratory testing of the overall system under test. Upon execution in the system under test, the test case is considered successful if each building block in the chain executes successfully; if any building block fails, the test case, in its entirety, is considered a failure.

Abstract: A method for repeating program flow for debugging and testing purposes comprises storing function call data in one or more files and retrieving the recorded data from the one or more files. The method further comprises using the recorded data to recreate an execution path of a program. Additionally, the method comprises analyzing the execution path to determine a source of an error in the program.

Abstract: Methods and systems are provided for associating contextual data with communication sessions, in particular in technical help desk scenarios. A context logger service running on a central server or on an individual computing device is used to create a log of application specific, often ephemeral, contextual data for a plurality of applications running one or more systems that are in communication with the context logger service across one or more networks. When a communication session between an initiating entity and a receiving entity to request assistance regarding a subject application running on one of the systems is initiated, and if the communication session is deemed to be a candidate for the automatic association of such context data, at least a portion of the application specific contextual data contained in the log is associated with the communication session and delivered to the receiving entity.

Abstract: This invention includes a state machine entering a first state upon cold reset of the data processing system. Trace information collection and trace information export are prohibited in the first state. The state machine transits from said first state to a second state upon a change in a predetermined bit to a first state. Direct memory access setup is enabled in the second state. The state machine transits from the second state to a third state upon set up of the direct memory access. Trace information collection is enabled in the third state. The state machine transits from the third state to a fourth state upon a direct memory access request corresponding to the direct memory access setup in the second state. Trace data export via direct memory access from the trace collection unit is enabled in the fourth state.

Abstract: A kernel trace system is described that acts as a kernel driver to insert traces into an open system kernel using existing kernel probe application-programming interfaces (APIs) and copies these events to an existing logging module for transfer to user space. The new module aggregates kernel traces to a performance logging module. A performance logging module can be extended with the kernel trace system herein to include new events in an open kernel not originally included in the implementation of the performance logging module. In this way, the kernel trace system can cause events to be logged that were not logged in the kernel as provided by the operating system vendor, and can do so without requiring that a new version of the operating system be built. The probes can be inserted dynamically at run time on an existing kernel to extract additional trace information.

Abstract: Methods for testing a computer program after changing a first version of the computer program into a second version of the computer program due to a revision of the computer program are provided. In one aspect, the method includes determining mutations inserted into the first version of the computer program, and the mutations inserted into the second version of the computer program, and comparing the first version of the computer program with the second version of the computer program to determine changed and unchanged mutations in the second version against the first version. The mutations that can be inserted only in the first version of the computer program or only in the second version of the computer program are classified as changed mutations and the mutations that can be inserted in the first and the second version are classified as unchanged mutations.

Abstract: Presented is a system and method for monitoring events derived from a computer target application presentation layer including the steps of providing, independent of recompiling the target application's source code, a script running at a level within the target application. The script scans run-time instantiations of objects of the target application, and allocates structures in real-time to the object instantiations. These allocated structures are adapted to create a reflection of the target application structure, which is used along with detected object instantiations that match a predetermined object structure to capture a portion of an environmental spectrum of the detected object. Further, the system can process state machine events occurring on at least one of a server machine and a client/localized machine, correlate the state machine events with the environmental spectrum, and deduce a user experience based on the correlated state machine events.

Abstract: Implementations of the present disclosure provide for testing an application, and include loading a testing tool by a client that is in communication with an application server that executes the application, introducing probe code into a routine by a first component of the testing tool, the routine being called during execution of the application, and transmitting a request to the application using a second component of the testing tool. An elapsed time of an execution of the routine is determined based on the probe code, and a response is generated from the application server based on the request. A response time is determined based on the request and the response, and performance statistics are calculated based on the elapsed time and the response time.

Abstract: A method of detecting a datarace between memory accesses within a program includes determining whether a datarace exists between a first access event in a first statement and a second access event in a second statement. It is then determined whether a third statement is more weakly protected than one of the first statement and the second statement.

Abstract: A tracing apparatus for tracing operational information that is output from a plurality of processing units in relation to data processing operations, the tracing apparatus comprising for each of the processing units: a counting unit configured to obtain and output a counter value for the corresponding processing unit, the counter value obtained by counting clock signals that are input to the processing unit at an operating frequency thereof; a counter value conversion unit configured to obtain and output a converted counter value for the corresponding processing unit, the converted counter value obtained by converting the counter value based on the assumption that the processing unit has a given reference operating frequency; and an adding unit configured to acquire an operational information set from the corresponding processing unit, and to add the converted counter value to the operational information set.

Abstract: A diagnostic system includes one or more processors for executing machine-executable instructions and one or more machine-readable storage media for storing the machine-executable instructions. The instructions include a plurality of traces. Each trace is a trace of events executing on a computing system. The system also includes processing logic configured to partition data in the trace into a first trace independent component which includes trace-independent information and a second trace dependent component which includes trace instance information. The system further includes a memory for storing the first trace independent component in a first data structure and the second trace dependent component in a second data structure.

Abstract: A method for optimizing the object code of a program is disclosed. A compiler generates, respectively, first and second object code segments for first and second source code segments of the program. If the two object code segments are determined to be identical, the compiler generates first and second debugging information entries in a compilation unit of the program and both entries include information for locating the first object code segment. The compiler inserts two entries into a call table in the compilation unit, each entry including information for locating a respective call site that invokes a respective source code segment within a call stack of the program and information for locating a respective debug information entry. The call table is used for associating an operation within the first object code segment with one of the first and second source code segments at runtime.

Abstract: In one embodiment, the invention comprises partial fault tolerant stream processing applications. One embodiment of a method for implementing partial fault tolerance in a stream processing application comprising a plurality of stream operators includes: defining a quality score function that expresses how well the application is performing quantitatively, injecting a fault into at least one of the plurality of operators, assessing an impact of the fault on the quality score function, and selecting at least one partial fault-tolerant technique for implementation in the application based on the quantitative metric-driven assessment.

Abstract: A method and computer program product are provided for audiating the occurrence of debugger events within a software debugger. The method begins by assigning a sound characteristic to a debugger event occurring within a software program under debug. Next, the audiation of the sound characteristic associated with the event is optimized to maximize performance of the debugger. Finally, the optimized sound characteristic associated with the event is played upon the occurrence of the event.

Abstract: A debugging system receives traceback data representing logging of a system error of a target system. An operating environment of the target system is replicated by creating a virtual machine (VM) having characteristics represented by the state data representing an operating state of the target system. An analysis is performed on the traceback data within the VM to simulate the system error.

Abstract: A test method for a handheld electronic device application is introduced. The test method is for testing a handheld electronic device installed thereon with an open operating platform and equipped with a touchscreen by executing a test program installed on the open operating platform to perform a test procedure. The test program identifies selected coordinates displayed on the touchscreen and corresponding to an application, instructs the open operating platform to execute the application based on the selected coordinates, records execution results, and exits an operating interface for the application to execute the application again. The test method cuts labor-related costs, maintains testing stability of the application, and yields reliable test results.

Abstract: Method, system, and computer program product embodiments of a time-based trace facility for facilitating software debugging without interfering with the run-time behavior, performance or resource usage of the traced software are provided. The trace facility resides in a different address space than the target address space and uses different time-slices of CPU resources to execute the instructions in the address spaces. The trace facility uses a cross-memory mode to read the state data from the target address space in accordance with a time schedule. The trace facility writes the state data to a trace area, which may be located in either the target or trace address spaces or external storage. With this approach, the trace facility can read a large amount of state data frequently to construct the type of historical record needed to analysis run-time behavior, performance and resource usage.

Abstract: A technique includes providing data indicative of a counted value acquired by a hardware counter of a processing core during a time segment in which a plurality of tasks are active on the core and, in a processor-based machine, determining a likelihood that the counted value is attributable to a given task of the tasks during the time segment and attributing a portion of the counted value to the given task based at least in part on the determined likelihood.

Abstract: A system and method for collecting instrumentation data in a processor with a pipelined instruction execution stages arranged in an out-of-order execution architecture. One instruction group in a Global Completion Table is marked as a tagged group. Instrumentation data is stored for processing stages processing instructions associated with the tagged group. Sample signal pulses trigger a determination of whether the tagged group is the next-to-complete instruction group. When the sample pulse occurs at a time when the tagged group is the next-to-complete group, the instrumentation data is written as an output. Instrumentation data present during sample pulses that occur when the tagged group is not the next-to-complete group is optionally discarded. Sample pulses are generated at a rate equal to the desired sample rate times the number of groups in the global completion table to better ensure occurrence of a next-to-complete tagged group.

Abstract: A host computer which generates a print job subjected to printing by a printer stores a drawing command output from an application in a spool file via a graphic engine. A spool system, the graphic engine, and a job chasing function processing unit execute a chasing data generation process by using the drawing command. The spool system, the graphic engine, and a graphics control unit execute a print data generation process by using the same drawing command. At this time, the drawing command is read out and output so as to successively execute the chasing data generation process and print data generation process. With this configuration, there are provided a method of protecting leakage of information by which the contents of information can be reliably chased without requiring either a special application or a device having a special function and posing any restriction on the read or output path, and an information processing apparatus and driver program which implement the method.

Abstract: A symmetric multi-processor SMP system includes an SMP processor and operating system OS software that performs automatic SMP lock tracing analysis on an executing application program. System administrators, users or other entities initiate an automatic SMP lock tracing analysis. A particular thread of the executing application program requests and obtains a lock for a memory address pointer. A subsequent thread requests the same memory address pointer lock prior to the particular thread release of that lock. The subsequent thread begins to spin waiting for the release of that address pointer lock. When the subsequent thread reaches a predetermined maximum amount of wait time, MAXSPIN, a lock testing tool in the kernel of the OS detects the MAXSPIN condition. The OS performs a test to determine if the subsequent thread and address pointer lock meet the list of criteria set during initiation of the automatic lock trace method.

Abstract: A method and system for the management of tracing data of interest in a data processing system comprises identifying the location and length of one or more such units of interest as each unit is stored in main memory during execution of the program and recording a logical assignment of each unit of interest to a slot in a wrap around trace buffer. Copying of the units of interest to the trace buffer is deferred unless one or more predefined events occur. Such events may include an attempt to overwrite the data which has been logically assigned or a request for information stored in the trace buffer. The recorded assignments are discarded whenever it is calculated that the capacity of the trace buffer would be exceeded resulting in the corresponding units never needing to be copied to the trace buffer.

Abstract: An execution time estimation device includes a program partitioning section that extracts partial programs partitioned by a conditional branch instruction or a function call instruction from a target program, a partial program execution time estimation calculating section that calculates the execution time of each of the partial programs to associate the leading instruction and the end instruction of each of the partial programs, and the calculated execution time with one another, a branch history information generating section that generates a branch history bit sequence which is a sequence of the true-false of the conditional branch instruction of when the target program is executed, an execution trace reproducing section that generates the execution sequences of the partial programs based on the branch history bit sequence, and an execution time estimation calculating section that adds the execution time of the partial programs based on the execution sequences of the partial programs.

Abstract: A method for software processing includes obtaining change information, which records changes that have been performed in respective locations in software code. The change information is processed so as to assign to at least some of the locations respective priorities, which are indicative of respective likelihoods that the locations contain program faults. The at least some of the locations are presented to a user in accordance with the assigned priorities.

Abstract: A debugging tool is provided that is capable of recording code paths taken during a program's execution, and along the way capture the memory state at configurable points in time such as function exits or statements. The tool also records interactions with external systems like a database, and captures which statements resulted in interactions with these systems. An analysis of the output of the debugging tool enables a developer to understand which part of the code executed; what the value of relevant variables were at configurable points in time; and which code statements correlate to which interactions with external systems.

Abstract: Systems, methods, and computer storage media having computer-executable instructions embodied thereon that facilitate static software program analysis using an interactive tool and/or a disassembly integration tool are provided. An interactive tool enables a user to view alternative error paths in association with an error such that the user can identify any valid errors within program code. A disassembly integration tool provides source code that is interleaved with an intermediate representation of such source code.

Abstract: A system, method, and computer program product are provided for removing a synchronization statement. In use, synchronization statements are identified. Additionally, the synchronization statements are analyzed. Furthermore, the synchronization statements are removed based on the analysis.

Abstract: A data processing system and method generates debug messages by permitting an external debug tool to have real-time trace functionality. A data processor executes a plurality of data processing instructions and uses a memory for information storage. Debug module generates debug messages including address translation trace messages. A memory management unit has address translation logic for implementing address translation to translate addresses between virtual and physical forms. The debug module includes message generation module that is coupled to the memory management unit for receiving notice when one or more address translation mappings are modified. The message generation module generates an address translation trace message in response to a detection of a modification of an address translation mapping occurs and provides the address translation trace message external to the debug module.

Abstract: Provided is a method for mitigating the effects of an application which crashes as the result of supplemental code (e.g., plug-in), particularly a plug-in from a source other than the source of the operating system of the device or the source of the application that crashes. The method includes executing the application. As the application is running, it may be monitored to determine if normal execution of instructions ceases. When that occurs, the system will make a determination if code from a supplemental code module was the cause of the crash, and will make an evaluation if that supplemental code module is from a source other than the source(s) of the operating system and application in question. In some implementations, remedial steps may be provided, such as providing information on subsequent executions of the application.

Abstract: A method of assessing a computer program under actual working conditions according to one embodiment comprises executing the computer program multiple times under actual working conditions, in response to each unhandled exception encountered during execution of the computer program, creating a corresponding stack frame signature to characterize the state of the program, and comparing the stack frame signatures to determine which unhandled exceptions are likely to have resulted from similar features.

Abstract: The present invention relates to application program logs. In particular, the invention relates to a method and a system in which an original log method of an application program is optimized and newly injected to the application program. According to one aspect of the present invention, there is provided a method for optimizing an application program log record, comprising: identifying an original log method of an application program; separating a character string parameter in the original log method into a constant part and a variable part; establishing a correspondence flag between the constant part and the variable part; constituting an optimized log method by the constant part, the variable part and the correspondence flag; and replacing the original log method with the optimized log method through a code injection. With the above method, the hard disk storage amount of the log record and the IO operation frequency can be reduced.

Abstract: A computer implemented method, apparatus, and program code for detecting malicious software components. A series of calls made by a software component is monitored to identify an identified respective series of call types to components named in the calls. A determination is made as to whether the identified respective series of call types to components named in the calls is indicative of malicious behavior.

Abstract: A method for enhancing functionality of an automated testing tool. Embodiments of the present invention provide for dynamically adjusting a date in an automated testing tool. System time in a system time format is adjusted according to a date offset. Embodiments of the present invention provide a method of formatting a date in an automated testing tool. System time in a system time format is accessed, wherein the system time comprises a current date and a current time. The date is formatted according to a predetermined date format. Embodiments of the present invention provide a method of regulating access to variables of an automated testing tool. An electronic document of the automated testing tool is populated with at least one variable and at least one value corresponding to the variable. In response to a request to access the variable, access to the variable and the value is provided.

Abstract: A method and an apparatus for diagnosing memory leak. The method includes: tracing the allocation of objects; recording allocation paths and allocation time of each object; giving to each object one unique identifier (ID) corresponding to an allocation path; determining the allocation path to which each object belongs; organizing the objects which are allocated but still not collected, and counting the age generations of the objects of the similar type according to the allocation time of each object; ranking the allocation paths according to the age generations of the surviving objects; and analyzing the ranking of the allocation paths, in which the allocation path with higher rank is more probable to introduce memory leaks. Thus, the suspicious allocation path possibly incurring memory leaks is selected and reported to the user for analysis.

Abstract: Various embodiments include at least one of systems, methods, and software to receive input configuring tests within a computing environment to expose users to standard application or website experiences or test experiences. In some embodiments, multiple tests may be configured to run orthogonally within user experiences without affecting the results of one another. Some such embodiments preserve the ability to execute certain tests in a non-orthogonal manner while other tests are allowed to execute orthogonally.

Abstract: A method for debugging the object code of a program is disclosed. While executing an object code segment on an information processing device, a debugger receives a location identifier associated with the object code segment and identifies a call site within a call stack of the program using the location identifier. The call site is responsible for invoking the execution of the object code segment. Next, the debugger scans a call table for an entry of the call site that includes information for locating a debugging information entry within a compilation unit of the program. The debugger retrieves the debugging information entry from the compilation unit using the location information and identifies a unique one of multiple different source code segments as the one corresponding to the object code segment using a source code segment identifier in the debugging information entry.

Abstract: Systems and methods are described for coordinating error reporting among a plurality of managed runtimes that are concurrently executing in the same process. In accordance with various embodiments, an error reporting manager that executes concurrently in the same process as the managed runtimes coordinates error reporting among the managed runtimes in a manner that does not require the managed runtimes to be aware of each other or to communicate directly with each other.

Abstract: Methods for lock tracing at a component level. The method includes associating one or more locks with a component of the operating system; initiating lock tracing for the component; and instrumenting the component-associated locks with lock tracing program instructions in response to initiating lock tracing. The locks are selected from a group of locks configured for use by an operating system and individually comprise locking code. The component lock tracing may be static or dynamic.

Abstract: An executable high-level trace file generation system provides reduced debugging effort and time, particularly on initial startup of new or modified hardware. An executable program invokes high-level application programming interfaces (APIs), to perform various tasks. Instructions within the APIs generate a trace file documenting the invoked sequence of APIs by writing a line to a trace file that documents the API and input parameters received by the API. Upon completion of execution of the API, the return value may be documented as a comment line in the trace file. The resulting trace file is then re-executable as a script and may be edited to alter the sequence of APIs invoked and/or the arguments provided. The script interpreter may be a command line interface through which the APIs are invoked, and trace files may be similarly generated that document sequences of manually entered commands.

Abstract: Various technologies and techniques are disclosed for providing stepping and state viewing in a debugger application. A start and end breakpoint are assigned. Source code execution begins, and upon reaching the start breakpoint, a logging feature begins storing one or more values that may be impacted upon execution of code between the start breakpoint and an end breakpoint. More lines of source code are executed until the end breakpoint is reached. When the end breakpoint is reached, the debugger is put into break mode. While in break mode, a playback feature is provided to allow a user to play back a path of execution that occurred between the start breakpoint and the end breakpoint. The playback feature uses at least some of the values that were stored with the logging feature to show how each referenced variable changed in value.

Abstract: A method for software processing in which software locations are assigned priorities indicative of respective likelihoods that the locations contain program faults, based on review information pertaining to reviews that have been conducted on respective locations in software code. In some methods, a software location is detected to be critical based on the priorities.

Abstract: Method, system and computer program product for template-based vertical microcode instruction trace generation. An exemplary embodiment includes an instruction trace generation method, including generating a testcase for a millicoded instruction in an instruction trace pool, wherein the millicoded instruction is included in a parent instruction trace, processing the testcase to generate a millicode instruction trace snippet, editing the millicode instruction trace snippet to generate a templatized millimode snippet, processing the parent instruction trace, accessing the templatized millimode snippet, updating the templatized millimode snippet with a value from the parent instruction trace, and generating a millicoded instruction trace from the updated templatized millimode snippet.

Abstract: Methods are classified as simple or complex. Complex methods are modified to add a tracer. Methods classified as simple are not modified to add a tracer. There are many different standards that can be used within the spirit of the present invention to classify methods as simple or complex. In one embodiment, a method is complex if it meets three criteria: (1) the method has an access level of public or package; (2) the method is non-synthetic and (3) the method calls at least one other method. Methods that do not satisfy all three criteria are classified as simple methods.

Abstract: A computer-implemented method of developing software includes receiving successive code changes for a software product. Input is received specifying that one or more code changes involve a work item associated with development of the software product. A plurality of build runs of the software product is generated. Respective build runs of the plurality correspond to one or more of the successive code changes. Data is stored associating the work item with one or more build runs that each correspond to at least one of the one or more code changes specified as involving the work item. A user input selecting the work item is received; in response, respective identifiers of at least one build run of the one or more build runs associated with the work item are displayed.

Abstract: This document describes a dynamic data race detector that utilizes adaptive sampling techniques. The adaptive sampling techniques include locating threads during execution of a multi-threaded program and identifying thread-specific hot paths, thread-specific cold paths and lockset paths during execution of the program. Once these paths are identified, they are sampled, potentially at different rates. Any information gained during the sampling may be stored in a data race log, which a developer may use to correct any identified program bugs.

Abstract: The subject disclosure is directed towards testing program code in multiple process modes without developing separate test case source code for each process mode. Source code for one or more test cases is developed once in accordance with a standard template. Two or more process mode implementations associated with the one or more test cases are built using common source code. Based on a test command, one or more of the process mode implementations is selected for executing a test plan.

Abstract: Since multi-core processors have become the standard architecture for general purpose machines, programmers are required to write software optimized for parallelism. Verification of correctness is an important issue for parallel code because of its complexity. There are still tools missing that provide verification for complex code, such as testing the execution of code provides. Consequently, described herein are systems and methods to evaluate the correctness of program traces. Furthermore, the systems and methods described herein do not demand excessive computational requirements and the size of the program trace being evaluated increases.