Abstract: A data processing apparatus is provided comprising prediction circuitry for predicting a response of the data processing circuitry at at least one given execution point to execution of a program instruction; tracing circuitry for tracing operation of the data processing apparatus for outputting a prediction indicator indicating whether or not the predicted response is correct; a data store configured to store information relating to the predicted response of said data processing circuitry at the given execution point for use by at least one of said prediction logic and said tracing circuitry a later execution point; and a history buffer configured to store historical information with regard to one or more entries of the data store at a corresponding execution point previous to the given execution point to enable restoration of said data store to a state corresponding to said previous execution point.

Abstract: The present invention extends to methods, systems, and computer program products for debugging in a multiple address space environment. Embodiments of the invention include techniques for recording debug information used for translating between an abstract unified address space and multiple address spaces at a target system (e.g., a co-processor, such as, a GPU or other accelerator). A table is stored in the recorded debug information. The table includes one or more entries mapping compiler assigned IDs to address spaces. During debugging within a symbolic debugger, the recorded debug information can be used for viewing program data across multiple address spaces in a live debugging session.

Abstract: A technique includes providing first objects that are associated with an application session and in a processor-based system, identifying second objects in another application session corresponding to the first objects based at least in part on a comparison of the second objects to matching rules associated with the first objects.

Abstract: Architecture employs an iterative process that incrementally discovers inter-component interactions and explores local state spaces within each component. Thus, the architecture lazily constructs the behavior of the environment of a component in the target software system, and integrates the construction of the inter-component interactions with the model checking process itself, and hence, does not need to eagerly construct the interface process. Component-based state space reduction is applied during the exploration of the whole system. The architecture decomposes a target software system into a set of loosely coupled components where interactions between the components tend to be significantly simpler than interactions within each component. An iterative algorithm facilitates the component-based state space reduction, which is exponential, on the real large-scale software systems.

Abstract: A working set profiler can monitor an execution of a program or can monitor a user-specified portion of a program to identify methods executed within the monitored execution and associate memory page accesses with each of the identified methods. Memory page accesses are categorized as shared or exclusive, where a shared page is a page that is accessed by more than one method and where an exclusive page is a page that is accessed by only one method in the monitored portion of the program. A call tree can be constructed and augmented with the collected information regarding memory page accesses. Further, for shared pages, the name of the method with which a particular method shares the page access can be collected. The augmented call tree information can be analyzed and prioritized to identify methods whose elimination would reduce program latency.

Abstract: Methods and systems are provided for debugging application code in an on demand environment. The method includes executing the code on a server in the on demand environment; identifying a first location within the code having a suspected error; defining a first check point within the code corresponding to the first location; subsequently re-executing the code, including the first check point, on the server; creating a memory dump corresponding the first check point during re-execution of the code; and debugging the code based on the heap dump without suspending subsequent re-execution of the code.

Abstract: In embodiments of determining relevant events in source code analysis, a computing device includes a key event manager that is implemented to traverse executable paths in source code of executable software instructions, log events along the executable paths in the source code, and determine a defect in the source code along an executable path in the source code. A state machine is implemented to traverse back through the logged events and determine relevant events that are associated with the defect in the source code. An analysis output of the relevant events can then be generated to indicate the defect in the source code and a cause of the defect.

Abstract: A system and method are provided to customize profiling sessions. In one embodiment, a profiling session at a first virtual machine is initiated, the profiling session including tracking a profiling event occurring at threads, each thread having associated semantical information corresponding to a plurality of profiling entities. A request from a second virtual machine is received specifying extracting profiling information when a profiling entity executes a thread where the profiling event occurs. The profiling information relating to the profiling entity is extracted as requested by the second virtual machine. The profiling information is communicated to the second virtual machine.

Abstract: Exemplary embodiments employ a mapping among entities that are related to each other. The entities may include a graphical model, generated code, a generated report, a requirements document and/or an intermediate representation. The mapping may facilitate graphical identifications between parts of one entity that maps to part of another entity. The graphical identification may occur based on a selection of a part in one of the entities.

Abstract: A system and method configured to instrument code for in-production monitoring provides a polling thread. A main thread executes the code of an instrumented application program and the polling thread executes in the background. Therefore the polling thread does not reduce the performance of the application program execution while monitoring activities are performed. Additionally, the polling thread is configured to simplify the process of instrumenting code for Java management extensions (JMX) by navigating the application program structure to locate administrative objects to bind to JMX and registering the administrative objects with JMX to enable monitoring of the instrumented code.

Abstract: Hardware-assisted program tracing is facilitated by a processor that includes a root instruction address register, a program trace signature computation unit and a call signature register. When a program instruction having an address matching the root instruction address register is executed, a program trace signature is captured in the call signature register and capture of branch history is commenced. By accumulating different values of the call signature register, for example in response to an interrupt generated when the root instruction is executed, software that performs program tracing can obtain signatures of all of the multiple execution paths that lead to the root instruction, which is also specified by software in order to set different root instructions for program tracing. In an alternative implementation, a storage for multiple call signatures is provided in the processor and read at once by the software.

Abstract: A method of debugging a function upon function exit includes pausing program execution at the time of initializing the function, wherein the function initialization includes saving a set of registers on the stack, recording the value of the stack pointer, configuring a watchpoint register based on the recorded value, wherein the watchpoint register is configured to trap memory references of the function based on the recorded value of the stack pointer, and executing the function. Program execution will pause when it is exiting the function because of stack references made by the function epilogue to restore registers saved on the stack and the configured watchpoint registers.

Abstract: A microprogrammable electronic device has a first code memory storing instructions, and is configured to execute each instruction in the first code memory at a respective instruction cycle. The system comprises binary code generating means, and a tracing device. The binary code generating means form part of the device, and are configured to generate and output on a single pin of the device binary codes, each of which indicates a corresponding execution-related event, is generated and outputted at a corresponding instruction cycle, and has N bits, where N is an integer >=2. The tracing device is coupled with the single pin to receive the binary codes, and has a second code memory in which the instructions are stored. The tracing device is configured to trace instructions executed by the device, on the basis of the received binary codes and of the instructions stored in the second code memory.

Abstract: A technique to monitor events within a computer system or integrated circuit. In one embodiment, a software-accessible event monitoring storage and hardware-specific monitoring logic are selectable and their corresponding outputs may be monitored by accessing a counter to count events corresponding to each of software-accessible storage and hardware-specific monitoring logic.

Abstract: A method and an apparatus to continuously re-compile a code are described. The code can be compiled in a speculatively optimized manner from a source code to access an untyped variable according to a type prediction of runtime values for the untyped variable. Failures of the type prediction during the execution can be dynamically tracked. Each failure may be associated a runtime value with a type outside of the type prediction. The type prediction may be adjusted according to the failures tracked for future runtime values of the untyped variable. The source code can be recompiled for execution to optimize the access to the untyped variable for the future runtime values according to the adjusted type prediction.

Abstract: Methods and devices for controlling access to resources are disclosed herein.

Abstract: A method of code execution by a processor including duplicating a first set of instructions to generate a second set of instructions, modifying the second set of instructions, executing the modified set of instructions, and upon exiting the modified set of instructions, loading an updated state of the processor.

Abstract: A method and apparatus for retrieving a state of a processor at a time at which failure is detected. More specifically, the detection of one or more protocol errors results in the halting of operations of one or more system elements, and the retrieving of the state of the processor at the time of the failure.

Abstract: An instrumented execution environment may connect to an execution environment to provide detailed tracing and logging of an application as it runs. The instrumented execution environment may be configured as a standalone service that can be configured and purchased. The instrumented execution environment may be deployed with various authentication systems, administrative user interfaces, and other components. The instrumented execution environment may engage a customer's system through a distributor that may manage a workload and distribute work to the instrumented execution environment as well as other worker systems. A marketplace may provide multiple preconfigured execution environments that may be selected, further configured, and deployed to address specific data collection objectives.

Abstract: A trace monitor configured to trace an exchange of a plurality of signals between a master device and a slave device of the system on chip, wherein the plurality of signals have a number of requests and a number of responses; and track the number of requests and the number of responses made before and after tracing is activated to determine which Reponses of the number of responses to trace after tracing is activated and a remaining number of responses to trace after tracing is deactivated.

Abstract: Embodiments of the invention broadly contemplate systems, methods, apparatuses and program products providing a mechanism in a run-time environment or Virtual Machine (VM) which enables a user to specify the combination of method(s) and thread(s) the user wants to collect traces for, without having to make any modifications to the application source code.

Abstract: Embodiments of the invention may provide for collecting specified data each time that a call to a given method occurs, wherein a given call to the given method is associated with a set of arguments comprising one or more particular argument values for the given method, and the collected data includes an element uniquely identifying each of the particular argument values. The process may further include storing the collected data at a selected location, and selecting a call threshold for the given method, wherein the call threshold comprises a specified number of occurrences of the given call to the given method, when the program is running. The collected data may be selectively analyzed at the storage location, to determine whether an occurrence of the given call to the given method has exceeded the call threshold.

Abstract: Systems and methods are described for diagnosing behavior of software components in an application server. The application server can comprise a plurality of components that process incoming requests. A diagnostics advisor can be deployed with the application server and can determine an efficiency and/or inefficiency of each of the components of the application server or other middleware system. The efficiency determined by computing a ratio of the number of requests that completed execution during a particular sampling time period to the number of requests that were received. The inefficiency is the ratio of the number of requests that are still being executed at the end of the sampling time period to the number of requests that were received. The diagnostics advisor employs the determined efficiency and/or inefficiency to diagnose a misbehavior or other problem of the components in the application server.

Abstract: The disclosed embodiments relate to a system and a method for process discovery. Embodiments of the present invention comprise extracting process data from a data source, creating a trace using the extracted process data, wherein the trace comprises a plurality of events, and detecting a process model using the plurality of events.

Abstract: A bottleneck detector may use an iterative method to identify a bottleneck with specificity. An automated checkpoint inserter may place checkpoints in an application. When a bottleneck is detected in an area of an application, the first set of checkpoints may be removed and a new set of checkpoints may be placed in the area of the bottleneck. The process may iterate until a bottleneck may be identified with enough specificity to aid a developer or administrator of an application. In some cases, the process may identify a specific function or line of code where a bottleneck occurs.

Abstract: A method for concurrent management of adaptive programs is disclosed wherein changes in a set of modifiable references are initially identified. A list of uses of the changed references is next computed using records made in structures of the references. The list is next inserted into an elimination queue. Comparison is next made of each of the uses to the other uses to determine independence or dependence thereon. Determined dependent uses are eliminated and the preceding steps are repeated for all determined independent uses until all dependencies have been eliminated.

Abstract: Methods and apparatus for testing user interfaces are disclosed herein. An example method includes extracting object data from a file associated with a user interface; storing a plurality of object definitions corresponding to the extracted object data in a computer readable storage medium; and generating, at a computer having a tangible memory, a test script for the user interface using the object definitions, wherein the test script is to be generated based on one or more test definitions defining one or more attributes of the object definitions to be tested in the test script, and wherein the test script is to be generated based on one or more automation rules defining how the object definitions are to be tested.

Abstract: A computer program product and system for allowing license tools to detect the installation of applications that are not physically installed on a machine when an Application Virtualization Environments is used. In one embodiment of the invention, the license tools may further detect application usage. In one embodiment of the invention, a virtual installation signature may be defined. Agents in a target computer may be used to compare the virtual installation signature of an application with a localized list of potential applications to detect whether the software is installed on the target computer.

Abstract: Detecting localizable native methods may include statically analyzing a native binary file of a native method. For each function call invoked in the native binary, it is checked whether resources accessed through the function call is locally available or not. If all resources accessed though the native method is locally available, the method is annotated as localizable.

Abstract: Modern application tracing techniques are described herein that enable dynamic logging of events declared in a static manifest. Various events for logging can be declared in a static manifest. The static manifest may then be compiled to translate the declared events into a library of corresponding functions that can be called by “modern” applications written using dynamic code. Calls made to these functions from dynamic code are converted to corresponding static events and forwarded to existing tracing application programming interfaces (APIs) designed to handle logging of static events for “legacy” applications that use compiled code. In this manner, static functions that are compatible with tracing APIs can be created and called dynamically from dynamic code. This can occur without requiring administrative rights to install the code and while preserving existing features for legacy applications, such that a tracing log can include events from both modern applications and legacy applications.

Abstract: Methods, computer-readable media, and systems are provided for usability testing. Usability testing can include recording, via a testing tool, actions of a user of an application and interactions of the user with the application 102/104. Usability testing can also include comparing, via the testing tool, the actions and interactions of the user with a baseline flow of actions for the application 106. Usability testing can include identifying, via the testing tool, a usability problem with the application based on the comparison 108.

Abstract: A processor performance profiler is enabled to for identify specific instructions causing performance issues within a program being executed by a microprocessor through random sampling to find the worst-case offenders of a particular event type such as a cache miss or a branch mis-prediction. Tracking all instructions causing a particular event generates large data logs, creates performance penalties, and makes code analysis more difficult. However, by identifying and tracking the worst offenders within a random sample of events without having to hash all events results in smaller memory requirements for the performance profiler, lower performance impact while profiling, and decreased complexity to analyze the program to identify major performance issues, which, in turn, enables better optimization of the program in shorter developer time.

Abstract: A computer implemented method, a computer program product and a data processing system provide a method for modifying a computer program during execution of the computer program by a processor unit. A computer receives an instruction string. The instruction string has a new function data therein for replacing current function data of a function of the computer program during execution of the computer program by a processor unit. The function is capable of being changed during execution of the computer program to modify the behavior of the computer program. The computer replaces the current function data with the new function data. The new function data modifies the computer program. The computer program is modified while the computer program is executed by the processor unit.

Abstract: An apparatus, system, and method are disclosed for improved tracking of software item defects. The approach involves maintaining defect attributes for a particular software bug. Certain attributes are user-defined while others are derived. Attributes may be, for example, questions, requests for action, requests for approval, or others. The primary attributes and derived attributes for the bug are associated with users that are associated with the software bug, and a determination is made as to whether or not action is required by the individual users for the software bug using the attributes. If action is required, the user is alerted that action is required for the software bug. The actions and/or bugs may be presented to the user using an inbox format. The inbox may sort actions based on priority, what type of attribute is relevant to the user, or using other categorizations.

Abstract: A method for reporting build runs includes: obtaining code changes for a software product; identifying the code change as affecting a work item of a software product under development, the work item specifies a feature to be added to or a defect to be removed from the software product; generating (i) a plurality of build runs of the software product, respective build runs corresponding to one or more code changes; and (ii) data 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; receiving a user input selecting the work item; and in response to the user input, displaying respective identifiers of at least one build run of the one or more build runs associated with the work item, including presenting an identifier of the at least one build run.

Abstract: Example systems and methods for trace replay and simulation are presented. In an example, a trace player can simulate the interactions of a variety of systems by replaying a trace log of previous interactions between two of the systems. The trace log may be modified prior to the replay to substitute identifying session and system information, and parsed for relevant interaction data. The trace log data may be modified further, prior to or during reply, through a user interface, thereby allowing a user to dynamically interact with the replay and to assist with debugging or testing of the systems.

Abstract: The tool, MC/DC-Automatic Tool Generator automatically generates test data to satisfy Modified Condition Decision Coverage (MCDC) from input code/model. This tool reduces the effort required to generate MCDC test data significantly. In order to reduce the time required by model checkers, abstraction and optimization methodologies have been implemented to analyze typical reactive software model/code.

Abstract: This invention enables a target variable name to be confirmed without inputting all the character string even when a method of giving a name such as allocating a number to the end of the name is performed from the necessity to allocate a variable name having the same meaning to a plurality of different addresses. If narrowed down variable name exists in plurals and one or two or more continuous next character strings match each other among the variable names, the series of character strings without any choice are automatically adopted and confirmed as the character string of the target variable name without waiting for the input of an operator.

Abstract: A method and a system for tracing the execution of multiple software products. The system includes: a collecting tool that is configured for collecting and internally listing in a list trace files; a determining device for determining the format of each trace file on the list, and selecting, as function of the format and for each trace file on the list, an associated parser, the associated parser being configured to read the listed trace file and extract trace data of the listed trace file; a translator for translating the extracted trace data into a new dataset; and a Graphical User Interface for displaying at least a subset of said new dataset.

Abstract: A data structure of a run-time object having a hash value field. The data structure allows an object allocation site to be traced from the run-time object, the object allocation site being a site in a program allocating the run-time object. A method for allowing an object allocation site to be traced from a run-time object includes embedding a value corresponding to the object allocation site in the program. A hash-value field includes the embedded value and the object identifier, and the tracing is performed by identifying the object allocation site that corresponds to the embedded value. A computer system for tracing an object allocation site includes a memory that stores the run-time object; an acquirer that acquires the value from a hash value field; and an identification unit that identifies the object allocation site that corresponds to the acquired value.

Abstract: A technique for debugging code during runtime includes providing, from an outside process, a trigger to a daemon. In this case, the trigger is associated with a registered callback function. The trigger is then provided, from the daemon, to one or more designated tasks of a job. The registered callback function (that is associated with the trigger) is then executed by the one or more designated tasks. Execution results of the executed registered callback function are then returned (from the one or more designated tasks) to the daemon.

Abstract: An apparatus comprising a first core of a multi-core processor, a second core of a multi-core processor and a bus matrix. The first core may be configured to communicate through a first input/output port. The first core may also be configured to initiate a testing application. The second core may be configured to communicate through a second input/output port. The second core may also be configured to respond to the testing application. The bus matrix may be connected to the first input/output port and the second input/output port. The bus matrix may transfer data between the first core and the second core. The testing application may generate real-time statistics related to the execution of instructions by the second core.

Abstract: An improved software testing system is described. In various embodiments, the system may produce a glossary containing keywords from the program state information associated with a software application to be tested. The system may produce a state engine model for the software application utilizing the program state information associated with the software application. The system may generate a test script by causing the software application to move through states identified by the state engine model such that the test script can identify a sequence of steps or keywords from the glossary. The system may select a keyword based on the current state of the software application and persona information. A persona may indicate a type of testing.

Abstract: A computer program product comprises a computer useable medium. The computer useable medium has a computer readable program such that when the computer readable medium is executed on a computer, the computer is caused to configure a calling interceptor at a service invocation point corresponding to a first component service of a software application to monitor a service invocation made by the first component service of a second component service of the software application, record a first set of correlation data represented by a first correlation indicator into a trace file, record a unique identifier into the trace file, and send the unique identifier to the second component service thought the service invocation.

Abstract: A profiler may be detached from an actively running application by first sealing communications between the application and profiler, then evacuating the profiler by waiting for any profiler-modified or instrumented code to complete execution, profiler runtime code to complete execution, cleaning up any residual items from the profiler, and shutting down the profiler. The profiler may be operational in many different environments, including a managed environment such as a virtual machine and those environments having just in time compiling of executable code.

Abstract: Analyzing the performance of multi-threaded applications. An analysis and visualization of thread executions is performed on a graphical timeline using samples of thread execution. This allows users to understand when their application threads are executing, what they were executing, the degree of concurrency in thread execution, and the order in which work is performed in their application. The visualizations and analysis also allow users to sample thread execution contexts using a graphical user interface, as well as the generation of execution profile reports that may be filtered for a specific time range of execution and a subset of the threads running in the application.

Abstract: A trace output unit for collecting, buffering and outputting trace data generated by trace circuitry monitoring processing activities of a data processing apparatus is described. The trace output unit comprises an input for receiving a stream of trace data; a plurality of data stores arranged in parallel with each other for storing the trace data; and storage control circuitry for controlling storage of items of the trace data in the data stores. The control circuitry is configured to route the trace items to selected ones of the data stores and to store control data identifying related trace items stored in different data stores. The trace output unit further comprises output control circuitry configured to identify related trace items stored in different data stores from the stored control data and to recombine the related trace items from different data stores to form an output trace data stream.

Abstract: A dataflow program defining actors that pass tokens from one to another via connections is processed by causing one or more processors to access and execute instructions of the dataflow program. Execution of the dataflow program generates events (e.g., token production/consumption, actor state after actor action firing). For each generated event, processing evaluates whether there exists a sequence of events that matches a breakpoint condition, and if such a sequence exists then execution of the dataflow program is halted. The breakpoint condition is at least partially based on an extended history of related events, wherein two events are related to one another if they pertain to a same connection or if they pertain to a same actor state, and wherein the extended history comprises at least two related events.

Abstract: The invention efficiently provides user code information for kernel level tracing approaches. It applies an advanced variation of stack walking called multi-mode stack walking to the entire system level and generates the unified trace where the user code and kernel events are integrated. The invention uses runtime stack information and internal kernel data structures. Therefore, source code for user level code and libraries are not required for inspection. The invention introduces the mechanism to narrow down the monitoring focus to specific application software and improve monitoring performance.

Abstract: At least some of the illustrative embodiments are a computer-readable medium storing a program that, when executed by a processor, causes the processor to obtain values indicative of a state of an operating context parameter during execution of a traced program on a target processor, and display an indication of a proportion of time during a trace period of the traced program that the target processor operated with the operating context parameter in a particular state.