Inventors list

Assignees list

Classification tree browser

Top 100 Inventors

Top 100 Assignees


Including instrumentation and profiling

Subclass of:

717 - Data processing: software development, installation, and management

717100000 - SOFTWARE PROGRAM DEVELOPMENT TOOL (E.G., INTEGRATED CASE TOOL OR STAND-ALONE DEVELOPMENT TOOL)

717124000 - Testing or debugging

Patent class list (only not empty are listed)

Deeper subclasses:

Class / Patent application numberDescriptionNumber of patent applications / Date published
717130000 Including instrumentation and profiling 89
20080276227Method and System for Adaptive, Generic Code Instrumentation using Run-time or Load-time generated Inheritance Information for Diagnosis and Monitoring Application Performance and Failure - The present system and method provides a system for generic, run-time adaptive placement of bytecode instrumentation, taking object oriented inheritance relationships into account. Said inheritance relationships are stored in an inheritance repository. The inheritance repository that mirrors the structure of the monitored application is created at run-time and updated if the code base of the monitored application changes either dynamically at run-time or by manually changing the configuration and restarting the application. The inheritance repository contains meta-data of application classes and their relationships, like direct and indirect inheritance. The inheritance repository information is used to evaluate generic instrumentation placement rules, like rules that match to methods of classes that inherit from a specific base class. The inheritance repository is generated concurrently to instrumentation placement at application load-time or run-time and is persisted between application runs to enable dedicated adaptation runs to create the repository. Detection of class relationships and instrumentation placement at run-time make the presented system suitable to monitor adaptive applications that dynamically adapt used components, libraries and execution code according to run-time conditions.11-06-2008
20120246625SYSTEM AND METHOD OF SOFTWARE EXECUTION PATH IDENTIFICATION - A method and system for creating uniquely representative execution path identifiers of software program. The method comprises the steps of running the software program, continuously accessing execution information of the software program, identifying execution sequences of the execution information, and creating a unique execution path identifier of each of the execution sequences by summing the execution information when the execution information is within a functional boundary thereof so as to create an execution path identifier representing a unique execution sequence of the execution information. The system comprises an execution path identification creator continuously receiving and accessing execution information of the software program, identifying execution sequences of the execution information and creating the unique execution path identifier of each of the execution sequences.09-27-2012
20090138858Data Driven Profiling for Distributed Applications - An exemplary method includes providing an application that includes client-side code and server-side code, instrumenting the client-side code and the server-side code to generate timestamps, distributing the instrumented client-side code and the instrumented server-side code and monitoring timestamps generated during execution of the application. In such a method, where timestamps generated by the client-side code and timestamps generated by the server-side code occur along a common timeline, a developer can monitor performance of the distributed application. Other exemplary methods, systems, etc., are also disclosed.05-28-2009
20090158258Instrumentation information gathering system and method - Description of a instrumentation information gathering system and method are presented in accordance with embodiments of the present invention. The present invention instrumentation information gathering systems and methods can be utilized to facilitate efficient and flexible instrumentation information gathering. In one embodiment, a static variable associated with instrumentation information is established. Primary code operations are performed and instrumentation information associated with the primary code operations is gathered, wherein the gathering utilizes the static variable.06-18-2009
20090307669MEMORY MANAGEMENT FOR CLOSURES - Methods, software media, compilers and programming techniques are described for binding data to a function using thunk synthesis. In one exemplary method, a computing system executes a program having a function with a first set of arguments. In response to the function being called, a function pointer of the function is synthesized to recover an extra argument for the function in addition to the first set of arguments.12-10-2009
20130074051TRACKING AND ANALYSIS OF USAGE OF A SOFTWARE PRODUCT - A method for tracking and analysing usage of a software product, comprising: (a) collecting data relating to usage of instances of the software product from multiple user devices, wherein the user devices each execute an instance of the software product instrumented to capture the data, and the collected data includes data relating to (i) features of the software product invoked on the user devices, and one or more of: (ii) any errors occurred during the use of the software product and (iii) user feedback indicating satisfaction or dissatisfaction on the software product regardless of whether an error has occurred; and (b) analysing the collected data to determine at least one sequence of the features that is likely to lead to an error and/or a sequence of the features that is likely to lead to user satisfaction or dissatisfaction of the software product for facilitating enhancement of the software product.03-21-2013
20130067439INJECTING FAULTS INTO PROGRAM FOR TESTING - Aspects of the subject matter described herein relate to injecting faults into programs for testing. In aspects, a program is instrumented with instrumentation points. A request that an exception be raised at an instrumentation point is received. In response, a sink is configured to listen for the event associated with the instrumentation point. The sink is further configured to cause the exception to be raised to the program in response to receiving the event. The exception may be raised without modifying code of the program.03-14-2013
20120159455RATING INTERESTINGNESS OF PROFILING DATA SUBSETS - Systems and methods for rating interestingness of profiling data subsets are described. Profiling data including a set of nodes associated with at least one executed computer program is received. The profiling data contains a first set of scores corresponding to the resource consumption of the nodes. A second set of scores is identified from the profiling data, wherein a score of the second set of scores indicates a combined resource consumption of a corresponding node of the set of nodes and at least one other node of the set of nodes related to the corresponding node. An interestingness rate is evaluated for groups of nodes of the set of nodes based on the corresponding scores. The group of nodes with the highest, or satisfactory high value of the calculated interestingness rate is presented.06-21-2012
20110283266Software Performance Profiling in a Multi-Tenant Environment - A method for software performance analysis and debugging in a multi-tenant database network system is provided. In at least one embodiment, sampling is achieved using configuration files of each server cluster. Knowledge of the host names of each server in the cluster enables a profiler to target a single server for each sample, thereby facilitating a round-robin sample across a clustered server environment such that a CPU's load and processing cost associated to sampling is fairly and uniformly distributed across all servers in the cluster. As a result, in at least one embodiment of the analysis and debugging tool each sample is a complete stack trace dump of each thread running on the application server at that moment in time.11-17-2011
20110283265FAILSAFE MECHANISM FOR DYNAMIC INSTRUMENTATION OF SOFTWARE USING CALLBACKS - A failsafe mechanism for installing and removing temporary instrumentation during a runtime of an application. Initially, an application is configured with a baseline set of instrumented components such as methods. Additional instrumentation is then deployed in the application, such as to diagnose a performance problem. The failsafe mechanism ensures that the additional instrumentation is automatically removed, even when there is an interruption in a communication link to the application, a computing device failure, a software failure, or some other type of failure, which renders it impossible to manually roll back the instrumentation from a remote user interface. The failsafe mechanism can be provided using callbacks between the computing devices which detect when a connection is unexpectedly lost or closed. Termination of one callback can cascade to one or more other callbacks. The instrumentation rollback can involve reloading un-instrumented byte code of the application.11-17-2011
20110283264DETECTION OF METHOD CALLS TO STREAMLINE DIAGNOSIS OF CUSTOM CODE THROUGH DYNAMIC INSTRUMENTATION - A technique for analyzing software in which un-instrumented components can be discovered and dynamically instrumented during a runtime of the software. Initially, an application configured with a baseline set of instrumented components such as methods. As the application runs, performance data is gathered from the instrumentation, and it may be learned that the performance of some methods is an issue. To analyze the problem, any methods which are callable from a method at issue are discovered by inspecting the byte code of loaded classes in a JAVA Virtual Machine (JVM). Byte code of the class is parsed to identify opcodes which invoke byte code to call other methods. An index to an entry in a constants pool table is identified based on an opcode. A decision can then be made to instrument and/or report the discovered methods.11-17-2011
20110283263CONDITIONAL DYNAMIC INSTRUMENTATION OF SOFTWARE IN A SPECIFIED TRANSACTION CONTEXT - Techniques for analyzing software in which un-instrumented components can be discovered and conditionally instrumented during a runtime of the software. Initially, software such as an application can be configured with a baseline set of instrumented components such as methods. As the application runs, performance data gathered from the instrumentation may indicate that the performance of some methods is below expectations. To analyze this, any methods which are callable from a method at issue are discovered, such as by inspecting the byte code of loaded classes in a JAVA Virtual Machine (JVM). To limit and focus the diagnosis, the instrumentation which is added to the discovered components can be conditional, so that the instrumentation is executed only in a specified context. The context can involve, e.g., a specified sequence of components in which a discovered component is called, and/or transaction data in which a discovered component is called.11-17-2011
20110289487FRAMEWORK FOR A SOFTWARE ERROR INJECT TOOL - Provided are techniques for receiving an error inject script that describes one or more error inject scenarios that define under which conditions at least one error inject is to be executed and compiling the error inject script to output an error inject data structure. While executing code that includes the error inject, an indication that an event has been triggered is received, conditions defined in the one or more error inject scenarios are evaluated using the error inject data structure, and, for each of the conditions that evaluates to true, one or more actions defined in the error inject script for the condition are performed.11-24-2011
20090150871METHOD AND APPARATUS FOR DEFINING AND INSTRUMENTING REUSABLE JAVA SERVER PAGE CODE SNIPPETS FOR WEBSITE TESTING AND PRODUCTION - Reusable JSP code snippets are defined and instrumented for Website testing and production. A user may define tile definitions in a markup language file for a number of JSP code snippets to be included in a store page. Upon receiving store inputs comprising tile definitions and jar files for the features, tables may be generated that map features to stores and features dependencies to features. Based on the tables, the store inputs may be validated. If no error occurs, run time files may be generated and JSP code snippets may be instrumented to the appropriate location for Website testing and production.06-11-2009
20090070748POINTERS FOR WRITE ABORT HANDLING - A portion of a nonvolatile memory array that is likely to contain, partially programmed data may be identified from a high sensitivity read, by applying stricter than usual ECC requirements, or using pointers to programmed sectors. The last programmed data may be treated as likely to be partially programmed data. Data in the identified portion may be copied to another location, or left where it is with an indicator to prohibit further programming to the same cells. To avoid compromising previously stored data during subsequent programming, previously stored data may be backed up. Backing up may be done selectively, for example, only for nonsequential data, or only when the previously stored data contains an earlier version of data being programmed. If a backup copy already exists, another backup copy is not created. Sequential commands are treated as a single command if received within a predetermined time period.03-12-2009
20090019429Virtualization of data source components in subject-oriented graphical programming environments for test and measurement applications - A subject-oriented graphical programming environment, for the design and construction of virtual instrumentation systems, comprises means enabling the visualization of data sources, control sources, data sinks, and events, thereby maximizing hardware device interchangeability and allowing device simulation. Said means comprise a decoupling software layer for decoupling the data connection aspects of a development environment from its visualization, data processing and control components. The decoupling layer comprises a “Jack” component type, to interface with the data connection components of an application, linkable to a “Plug” type component that interfaces with the rest of the application. Jack and Plug components are configurable by application developers using graphical tools, providing users with broad discretion to define their own data acquisition virtual interfaces, rather than being limited to using an existing data connection component directly.01-15-2009
20110113407Software routine fingerprints in performance data - Program profile data is used to prepare temporal cost-incurrence fingerprints, which show when a given method or method frame incurred specified cost(s) during a period of interest while a program was/is executing. Relationships between methods can be elicited by studying their temporal cost-incurrence fingerprints. Methods which are often good candidates for optimization can be automatically selected by identifying a small set of methods whose amount of cost lies within specified bounds relative to the most costly method, or in absolute terms, and whose respective fingerprints differ from one another.05-12-2011
20100100873Instrumentation of Computer-Based Application Software - A method for instrumenting a computer-based software application, the method including instrumenting instructions of a computer-based software application, the instructions being in a first computer instruction language, with a native handler referencing instructions in a second language, and creating the instructions referenced by the native handler in the second computer instruction language to carry out at least one task during the execution of the computer-based software application.04-22-2010
20090007077AUTOMATICALLY GENERATING TEST CASES FOR BINARY CODE - The present invention extends to methods, systems, and computer program products for automatically generating test cases for binary code. Embodiments of the present invention can automatically generate test inputs for systematically covering program execution paths within binary code. By monitoring program execution of the binary code on existing or random test cases, branch predicates on execution paths can be dynamically inferred. These inferred branch predicates can then be used to drive the program along previously unexplored execution paths, enabling the learning of further execution paths. Embodiments of the invention can be used in combination with other analysis and testing techniques to provide better test coverage and expose program errors.01-01-2009
20080244537Method and system for customizing profiling sessions - 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.10-02-2008
20110202904Hierarchical aggregation system for advanced metering infrastructures - A coverage analysis tool may determine coverage in respect to heterogeneous coverage tasks associated with different hierarchy levels of a tasks hierarchy. The coverage analysis tool may iteratively refine coverage tasks to determine coverage of sub-tasks. In some cases, coverage tasks may be unrefined in order to reduce overhead of coverage analysis in performance of the software under test, such that the software under test may perform in an essentially similar manner as in non-testing mode.08-18-2011
20090083717BENCHMARK PROFILING FOR DISTRIBUTED SYSTEMS - Embodiments of the invention may be used to generate a benchmark profile for a computing job configured to execute on distributed systems. The benchmark profile may be used to predict the performance of components of a computing job for a variety of different distributed computing system architectures. A profiling tool evaluates the computing job to identify the particular performance characteristics of the application and match this with benchmarks that are most representative of the identified performance characteristics and store them in the benchmark profile. The identified benchmarks may then be run on different configurations of a distributed computing system in order to predict the performance of the application for a variety of scenarios.03-26-2009
20120144375REVERSIBLY INSTRUMENTING A COMPUTER SOFTWARE APPLICATION - A method, system, and computer program product for reversibly instrumenting a computer software application is described. The method may comprise creating a map indicating a plurality of locations of application instruction sections within instructions of a computer software application. The method may further comprise inserting a plurality of instrumentation sections into the computer software application instructions. The method may also comprise updating the map to indicate the locations of the instrumentation sections within the computer software application instructions, where the indications in the map of the locations of the instrumentation sections are distinguishable from the indications in the map of the locations of the application instruction sections. The method may additionally comprise updating the map to indicate a change in any of the locations of any of the application instruction sections within the computer software application instructions subsequent to inserting the instrumentation sections.06-07-2012
20090210863CODE-BASED WEBSITE EXPERIMENTS - Systems and methods for code-based website experiments. Code-base website experiments can include specification of an identified section of program code to be experimented upon as well as one or more alternative sections of program code to replace the identified section of program code in the experimental landing page configurations. Statistics associated with the program code sections can be analyzed to determine which of the program code sections performs better than the other program code sections.08-20-2009
20090249306Off-Line Program Analysis and Run-Time Instrumentation - A technique is disclosed for determining off-line the number and location of instrumentation probes to be inserted into a program under testing, and subsequently instrumenting the program at run-time based on the off-line analysis. In accordance with the illustrative embodiment, an off-line analyzer first determines instrumentation locations for a program under test in accordance with a method called the Super Nested Block Method. After the instrumentation locations have been determined, a testing/monitoring tool executes the program and a run-time instrumenter in parallel. The run-time instrumenter accordingly inserts probes into the program, removes probes after they have been executed once, and generates and reports information about code coverage based on the probes.10-01-2009
20090249305Super Nested Block Method to Minimize Coverage Testing Overhead - A method for determining the number and location of instrumentation probes to be inserted into a program is disclosed. The method advantageously inserts the minimum number of probes that are required to obtain execution coverage for every node in the program's control-flow graph. In addition, the method requires only one bit to store each probe and does not require the assignment of weights to arcs or nodes of the control-flow graph. In the illustrative embodiment, the nodes of a control-flow graph are partitioned into non-empty sets, where each non-empty set corresponds to a super nested block of the program.10-01-2009
20090172646METHOD FOR DYNAMIC DISCOVERY OF CODE SEGMENTS IN INSTRUMENTED BINARY MODULES - A method for dynamic discovery of code segments in instrumented binary modules is provided. A program comprising code segments is received. Potential code segments are determined, and the program is instrumented at potential code segments for dynamic code discovery. The instrumented program is run. In response to executing the potential code segments, the potential code segments are marked. The marked code segments are stored as confirmed code segments.07-02-2009
20090254889JUST-IN-TIME DYNAMIC INSTRUMENTATION - Just-in-time dynamic instrumentation of a running software system may be achieved by registering one or more instrumentation probe handlers in an inactive state wherein the probe handlers reside in a memory space associated with the software system but are not instrumented into the software system. The probe handlers may each have one or more probe handler tags representing categories to which the probe handlers have been assigned. Tag query requests are periodically received and processed in order to provide information to a caller about registered probe handlers associated with a probe handler tag specified in the tag query request. A probe handler activation request can be made by specifying a probe handler or a probe handler tag. The request can be processed by placing the specified probe handler, or probe handlers associated with the tag, in an active state. The software system thus becomes dynamically instrumented to execute the probe handler(s) as part of the software system's execution flow. The activated probe handler(s) may be returned to the inactive state in response to a probe handler deactivation request specifying a probe handler or a probe handler tag.10-08-2009
20080307396Profiler Management - A profiler manager may attach and detach profilers from a running application. A profiler may be detached through a two step process where the profiler is sealed from communicating with the running application, then an evacuation step where the application is able to complete any responses that are pending. While the profiler is in the evacuation phase, another profiler may be attached to the application. Messages to the evacuating profiler may be captured and directed to the proper profiler.12-11-2008
20090094584NON-INTRUSIVE ASSET MONITORING FRAMEWORK FOR RUNTIME CONFIGURATION OF DEPLOYABLE SOFTWARE ASSETS - The present invention discloses a solution for metering, monitoring, and monetizing software assets. The solution can include a step of registering a software asset with a monitoring service. A unique identifying key for the software asset can be generated during registration. The software asset can then be instrumented for the monitoring service. The instrumentation can reference the software asset by the unique key. Specifics of the set of metrics that are to be monitored by the monitoring service for the software asset can be runtime, development time, and/or deployment time configurable. The instrumented software asset can convey transaction data to the monitoring server when used by clients. Analyzed results produced by the monitoring service pertaining to the software assets based upon the transaction data can be provided to authorize users of vendors associated with the software asset.04-09-2009
20120198424Providing Programming Support to Debuggers - Method for providing programming support to a debugger are disclosed. The method includes defining at least one debugger programming statement, and instructing the debugger to execute the at least one debugger programming statement which modifies a least a portion of the computer program during execution of the computer program without recompiling the computer program. The debugger may be instructed to execute the at least one debugger programming statement at a specified position of the computer program. The at least one debugger programming statement may include a delete instruction that instructs the debugger to prevent one or more programming statements at a specified position in the computer program from being executed. The debugger may be instructed to execute the at least one debugger programming statement instead of one or more programming statements at a specified position in the computer program without recompiling the computer program.08-02-2012
20130219373STACK OVERFLOW PROTECTION DEVICE, METHOD, AND RELATED COMPILER AND COMPUTING DEVICE - The present disclosure relates to a stack overflow protection device and a stack protection method. According to the present disclosure, a stack overflow protection device is provided, which includes a dividing unit configured to divide at least one function in the input codes into a code region with a string operation and a code region without a string operation. The device also includes a stack protection unit configured to set up stack protection in the code region with a string operation. The present disclosure further provides a stack protection method.08-22-2013
20100199265PROGRAM DEBUGGING WITH DYNAMICALLY INSERTED INSTRUMENTATION - The present disclosure simplifies programming debugging by dynamically injecting debugger compiled instrumentation into the debuggee process such that the debuggee process executes the instrumentation without executing the debugger. In one example method, the debugger controls compiling a description of the instrumentation as an instrumentation method. The debugger can then write the instrumentation method into the debuggee. The debuggee can save the state of a target method of the debuggee process at a predetermined location. The debuggee process calls the instrumentation method from the debuggee. In addition, the state of the target method can be restored and the resumed from the predetermined location after the instrumentation method executes.08-05-2010
20090276763Bounding Resource Consumption Using Abstract Interpretation - Bounding resource consumption of code using abstract interpretation includes a static analysis to estimate a code's resource consumption in terms of units of resources utilized at any point during execution, expressed as a function of its scalar inputs. An instrumentation mechanism and an abstract interpretation mechanism are employed to compute bounds on the code resource consumption. The instrumentation mechanism includes incorporating one or more counter variables in the source code to count the number of loop iterations and recursive procedure call invocations. The abstract interpretation mechanism includes computing invariants on the instrumented counter variables and scalar program variables to obtain bounds on the number of loop iterations and recursive procedure call invocations, which are then composed together to obtain resource bounds for the entire program.11-05-2009
20090113400Device, System and method of Profiling Computer Programs - Device, system, and method of profiling computer programs. For example, a method for profiling computer programs includes: profiling a program statement associated with a machine-readable comment indicating an expectation by a programmer of a runtime behavior of the program statement.04-30-2009
20090113399Device, System and Method of Debugging Computer Programs - Device, system, and method of debugging computer programs. For example, a method for debugging computer programs includes: locating a bug in a computer program based on a first score corresponding to a first instrumentation location of the computer program and a second score corresponding to a second instrumentation location of the computer program.04-30-2009
20100223599EFFICIENT SYMBOLIC EXECUTION OF SOFTWARE USING STATIC ANALYSIS - In one embodiment, a method includes accessing software comprising one or more inputs, one or more variables, and one or more segments of code that when executed operate on one or more of the inputs or one or more of the variables. The method includes, for every variable, determining whether the variable is relevant or irrelevant to a set of the inputs when expressed symbolically and, if the variable is relevant, instrumenting the variable and every one of the segments of code associated with the variable. A segment of code is associated with the variable if the variable affects the segment of code when executed. The method includes symbolically executing the software with every relevant variable and its associated segments of code as instrumented to test the software.09-02-2010
20100306745Efficient Code Instrumentation - A method for instrumenting a computer program, the method including identifying a program slice within a computer program, and instrumenting the program slice within the program.12-02-2010
20110126176Providing Programming Support to Debuggers - Method, system, and computer program product for providing programming support to a debugger are disclosed. The method includes defining at least one debugger programming statement, and instructing the debugger to execute the at least one debugger programming statement which modifies a least a portion of the computer program during execution of the computer program without recompiling the computer program. The debugger may be instructed to execute the at least one debugger programming statement at a specified position of the computer program. The at least one debugger programming statement may include a delete instruction that instructs the debugger to prevent one or more programming statements at a specified position in the computer program from being executed. The debugger may be instructed to execute the at least one debugger programming statement instead of one or more programming statements at a specified position in the computer program without recompiling the computer program.05-26-2011
20100011345Efficient and Self-Balancing Verification of Multi-Threaded Microprocessors - Creating one or more irritator threads on one or more processor cores in a multi-threaded multiprocessor data processing system is provided. A test generator generates non-irritator thread code for execution by a non-irritator thread and irritator thread code for execution by one or more irritator threads of the multi-threaded multiprocessor data processing system. A simulation controller instantiates the non-irritator thread to execute the non-irritator thread code and the one or more irritator threads to execute the irritator thread code. The simulation controller determines if the non-irritator thread has finished execution of the entire instruction stream of the non-irritator thread code. Responsive to the non-irritator thread finishing execution of the entire instruction stream of the non-irritator thread code, the non-irritator thread performs an operation to terminate the execution of the irritator thread code by the one or more irritator threads.01-14-2010
20110078664PROGRAM TRANSLATION METHOD AND NOTIFYING INSTRUCTION INSERTING METHOD - The present invention comprises: a converting step for converting a source program into a machine language program; an inserting step for inserting notifying instructions for notifying that the source program has been executed in the machine language program; and a program generating step for generating the executable program from the machine language program in which the notifying instructions are inserted. Further, in the inserting step, the notifying instructions are placed at the entry points of each basic block that constitutes the machine language program and the notifying instructions to which the same conditions as those of the conditional instruction groups are granted are placed at the entry points of conditional instruction groups provided in the machine language program. In the program generating step, identification information for identifying the notifying instructions is granted to each of the notifying instructions. According to this, the present invention enables analysis of the executed range in the program that includes the conditional instructions as well.03-31-2011
20130167124DETECTION OF CUSTOM PARAMETERS IN A REQUEST URL - Identifying at least one custom parameter in a request uniform resource locator (URL). The method can include identifying at least a first portion of source code of a Web application that typically consumes the custom parameter provided in the request URL and, via a processor, instrumenting the Web application at the first portion of the source code. The Web application can receive the request URL and the Web application can be executed with the instrumented source code. At least one run-time value consumed by the second portion of the source code can be identified, and the run-time value can be compared to the request URL to determine whether the run-time value intersects with the request URL. Responsive to determining that the run-time value intersects with the request URL, the run-time value can be identified as the custom parameter. A custom parameter rule can be generated based on the comparison.06-27-2013
20110016455Power Profiling for Embedded System Design - The power usage of software executable by an embedded system may be profiled without the need for test benches or power measurement systems. Additionally, the power profiles corresponding to multiple pieces of software may be determined and compared.01-20-2011
20100269102SYSTEMS, METHODS, AND APPARATUSES TO DECOMPOSE A SEQUENTIAL PROGRAM INTO MULTIPLE THREADS, EXECUTE SAID THREADS, AND RECONSTRUCT THE SEQUENTIAL EXECUTION - Systems, methods, and apparatuses for decomposing a sequential program into multiple threads, executing these threads, and reconstructing the sequential execution of the threads are described. A plurality of data cache units (DCUs) store locally retired instructions of speculatively executed threads. A merging level cache (MLC) merges data from the lines of the DCUs. An inter-core memory coherency module (ICMC) globally retire instructions of the speculatively executed threads in the MLC.10-21-2010
20100037211AUTOMATIC INCREMENTAL APPLICATION DEPENDENCY DISCOVERY THROUGH CODE INSTRUMENTATION - Disclosed is a method allowing the automatic discovery of application component dependencies by tracing application calls to dependant resources. The call tracing is embedded dynamically in an application at runtime using Common Intermediate Language (“CIL”) code instrumentation at compile time or runtime. Such a method reads an instrumentation configuration file to determine an address extraction code portion that is to be instrumented to an application method code, locates the CIL method body for the application method that is to be instrumented, instruments the application method by inserting the address extraction code portion into the appropriate .NET Application or .NET library at either compile time or at run time, extracts the address of one or more external service providers from the designated .NET library methods responsible for communication during execution of the application method that was instrumented, publishes any newly discovered dependencies to a management system in the form of the discovery event, and causes the management system to build an application dependency map based on the resource address information obtained.02-11-2010
20110154297DYNAMIC INSTRUMENTATION - A method and system for instrumentation are provided along with a method for instrumentation preparation. The method for instrumentation preparation may comprise obtaining address data of an original instruction in an original instruction stream, obtaining kernel mode data comprising a kernel breakpoint handler, obtaining user mode data comprising a user breakpoint handler, allocating a page of a process address space, creating a trampoline, associating the trampoline with a breakpoint instruction, and replacing the original instruction with the breakpoint instruction. The method for instrumentation may comprise detecting the breakpoint instruction, calling the kernel breakpoint handler, modifying an instruction pointer via the kernel breakpoint handler such that the instruction pointer points to the trampoline, and executing the trampoline. The system for instrumentation may comprise a breakpoint setup module and a breakpoint execution module for respectively setting up and completing instrumentation involving the trampoline.06-23-2011
20110154298COLLECTING COMPUTER PROCESSOR INSTRUMENTATION DATA - 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.06-23-2011
20110154299APPARATUS AND METHOD FOR EXECUTING INSTRUMENTATION CODE - An instrumentation apparatus and method capable of adding an additional operation to an execution program, are provided. A processor for supporting instrumentation assigns an instrumentation bit to an instruction that includes instrumentation code that needs to be executed. The processor jumps to an address of a memory for execution of the instrumentation code, and stores the jump address in a register. If a fetched instruction includes the instrumentation bit, the processor jumps to the jump address stored in the register and executes the instrumentation code.06-23-2011
20080313618Detaching Profilers - 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.12-18-2008
20110161936METHOD AND APPARATUS FOR REGRESSION TESTING SELECTION FOR A FRAMEWORK-BASED APPLICATION - A selection method and related application is provided for a framework-based application having programming applications with both language program files and configuration files. In one embodiment, the method comprises abstracting a frame configuration model instance by analyzing configuration files prior to any modifications made to the program. The frame configuration model instance denoting individual configuration nodes in the framework model and further defining relationship between one or more code units in the configuration nodes and program code units in the application. Then one or more control test cases are constructed by profiling select test cases of the application, wherein the control flow consists of code units traversed during test case execution and control flow of said code units. Subsequently, an extended control flow is obtained by correlating configuration nodes in the framework configuration model instance with the code units in said control flow.06-30-2011
20120311544SYSTEM AWARE PERFORMANCE COUNTERS - System aware performance counters including a processor for performing a method that includes executing a predefined code segment of an application, the executing on a processor. The executing includes executing an instrumented thread included in the predefined code segment. The method includes performing a first action associated with executing the instrumented thread in the predefined code segment, and registering the instrumented thread. A performance counter associated with the predefined code segment is started. Also, the execution of the predefined code segment is paused and the performance counter is paused. The method further includes performing a second action associated with pausing the executing of the predefined code segment. The executing of the predefined code segment is resumed and the performance counter is resumed responsive to resuming the executing of the predefined code segment. Also, a third action associated with resuming executing the predefined code segment is performed.12-06-2012
20110047532METHODS AND APPARATUSES FOR SELECTIVE CODE COVERAGE - Methods and apparatuses that collect code coverage information for selected code locations when executing executable code are described. Source code in one or more files may be annotated at the selected code locations. The executable code may be compiled from the annotated source code using standard compilers. The code coverage information may be collected into a run time data store accessible by other applications. In response to receiving a code coverage request, the code coverage information can be retrieved from the data store to compare with annotations identified from the source code. A code coverage report can be generated to indicate whether one or more of the selected code locations are not covered when executing the executable code.02-24-2011
20110047531METHODS AND APPARATUSES FOR SELECTIVE CODE COVERAGE - Methods and apparatuses that collect code coverage information for selected code locations when executing executable code are described. Source code in one or more files may be annotated at the selected code locations. The executable code may be compiled from the annotated source code using standard compilers. The code coverage information may be collected into a run time data store accessible by other applications. In response to receiving a code coverage request, the code coverage information can be retrieved from the data store to compare with annotations identified from the source code. A code coverage report can be generated to indicate whether one or more of the selected code locations are not covered when executing the executable code.02-24-2011
20100115495INTELLIGENT ENGINE FOR DYNAMIC AND RULE BASED INSTRUMENTATION OF SOFTWARE - Instrumentation is dynamically added to application components during runtime. An interestingness engine receives inputs from various sources which identify software components such as classes for which it is desired to provide instrumentation. The sources can include a heuristics engine which receives performance data from already-instrumented components, a user interface from which a user identifies component to be instrumented or de-instrumented, and a static list of components to be instrumented. During the runtime, instrumentation can be added to components which become interesting, or removed from components which become not interesting. When loading or redefining a component, if a component type matches rules, it is eligible for instrumentation, and the interestingness engine is consulted to determine whether the component is of interest, in which case instrumentation is added. If a component type does not match rules, but the component is interesting, the rules can be updated to include the component type.05-06-2010
20110138367METHOD AND SYSTEM FOR DETECTING MEMORY LEAKS - A method, system, and/or computer program product for detecting memory leaks in a computer application includes instrumenting one or more software methods to increment and decrement a reference count of a software object. The reference count of the software object may be set to a predetermined count when the software object is created. The one or more software methods instrumented to increment and decrement the reference count of the software object may be executed. When the one or more software methods return from execution, the method, system, and/or computer program product may determine whether the reference count is set to the predetermined count.06-09-2011
20110138366Profiling Data Snapshots for Software Profilers - Implementations of the present disclosure provide methods including executing a profiling session to profile one or more applications running on a virtual machine executed on a server, collecting profiling data over a first time interval during the profiling session, receiving user input generated at a client device, the client device being in communication with the server, in response to the user input, generating a snapshot corresponding to a subset of the profiling data, the snapshot being identified based on a second time interval that is within the first time interval, and transmitting the profiling data to generate a snapshot view for display on a client device, the snapshot view corresponding to the subset of the profiling data.06-09-2011
20110138365COMPONENT STATISTICS FOR APPLICATION PROFILING - Implementations of the present disclosure provide methods including executing an application using one or more processors, generating a plurality of method call stacks, each method call stack comprising a plurality of methods invoked by the application, providing a component call stack based on a method call stack of the plurality of method call stacks, the component call stack comprising a plurality of components, each component being defined by one or more methods of the plurality of methods, and generating component statistics based on the component call stack and profiling data collected during the executing.06-09-2011
20120011491EFFICIENT RECORDING AND REPLAYING OF THE EXECUTION PATH OF A COMPUTER PROGRAM - To monitor the execution path of executable code, only non-deterministic jump instructions of the executable code are instrumented by replacing them with respective recording instructions that record the results of executions of the non-deterministic jump instructions and then emulate those executions, thereby providing instrumented code, and the instrumented code is executed. Preferably, the recording instructions are one byte long and invoke an interrupt service routine that does the recording and the emulating. Optionally, selected instructions of the executable code are replaced with trigger instructions for turning the recording on and off. Preferably, after the instrumented code is executed, the addresses of the instrumented instructions and the results of their executions are played back either forward or backward. Optionally, the instrumented code is executed a second time and the results of the executions of the instrumented instructions in the two executions of the instrumented code are compared.01-12-2012
20120023487MEASURING ACTUAL END USER PERFORMANCE AND AVAILABILITY OF WEB APPLICATIONS - Techniques for monitoring web application performance are provided. A request for a web application is received at an application server. A response pipeline at the application server generates client application code corresponding to the requested web application. The client application code is intercepted in the response pipeline. Instrumentation code is inserted into the intercepted client application code to generate an instrumented client application code. The instrumentation code is configured to be executed when the instrumented client application code is rendered at the client to capture performance information at the client, and is configured to transmit the captured performance information from the client.01-26-2012
20130227531Methods and Systems for Modifying A Compiler to Generate A Profile of A Source Code - Systems and methods for modifying a compiler to generate a profile of a source code are described. One of the methods includes receiving the source code. The source code excludes instrumentation and includes functions. The method also includes compiling the source code with the compiler to generate metrics that are associated with execution of the functions within the source code. The compiling operation includes applying function tracking commands that were inserted into a compiler. The commands are used for tracking beginnings and ends of the functions to be tested.08-29-2013
20120159456INSTRUMENTED APPLICATION IN A MOBILE DEVICE ENVIRONMENT - A method for utilizing an instrumented application in a mobile device environment. The method includes instrumenting an application to generate an instrumented application configured for use in the mobile device environment, obtaining authorization from a governing body for use of the instrumented application in the mobile device environment, and directing the instrumented application to cause a mobile device to operate according to a first setting. The first setting is invoked without requiring further authorization by the governing body.06-21-2012
20120079460INSTRUMENTATION APPARATUS AND METHOD - Provided is an instrumentation apparatus and method for inserting an instrumentation function into a program. The instrumentation function may be inserted into code that is outside of a loop of a program or a system library function relevant to the program.03-29-2012
20110107313Integration of Visualization with Source Code in the Eclipse Development Environment - A computer implemented method involving receiving by an integrated development environment an output file from a profiling utility to generate a line chart of data from the output file. The method to visualize profiling data for a binary file automatically and to displaying corresponding source code in response to a user selection of a data point in the line chart.05-05-2011
20120222017METHOD AND APPARATUS FOR VISUALIZING COMPUTER PROGRAM EXECUTION - Analysis data from the execution of a computer program is collected. The analysis data may include samples of two different types of performance data from the execution of the computer program. Performance data may include sampled hardware performance counter data and sampled executing functions. The performance data is used to create a composite view of the data. The composite view may allow a user to efficiently correlate the different types of performance data by using a colored visual display.08-30-2012
20120317553Obtaining Profile Data for Use in Optimizing Computer Programming Code - Program execution profile data is collected by direct measurement of some code paths, and by inferring data for unmeasured paths. The data collection process may cause errors, which are propagated by the inferencing process. The profile data thus constructed is further enhanced by detecting certain data mismatches, and adjusting inferred data to reduce the scope of errors propagated during the inferencing process. Preferably, a control flow graph of the program being measured is constructed. Mismatches in the total weights of input arcs versus output arcs are detected. For certain specific types of mismatches, it can be known or guessed which count is incorrect, and this count is accordingly corrected. Correction of arc counts proceeds recursively until it is no longer possible to correct mismatches. Additionally, certain other conditions are adjusted as presumed inaccuracies.12-13-2012
20120167058METHOD AND APPARATUS FOR FLEXIBLE, ACCURATE, AND/OR EFFICIENT CODE PROFILING - An apparatus and method for profiling program code. In particular, an apparatus according to one embodiment comprises a filtering component identifying a first set of instructions for which profiling is desired wherein, in response to detecting that an instruction has been retired, the filtering component determines whether the instruction is within the first set of instructions for which profiling is desired; an event selection component detecting an event in response to the instruction retiring, the event selection component generating event signals in response to a designated event; and a profiling component recording the occurrence or not occurrence of the event within a first storage device responsive to signals from the filtering component and/or the event selection component.06-28-2012
20120167057DYNAMIC INSTRUMENTATION OF SOFTWARE CODE - A dynamic instrumentation system is described herein that performs dynamic, in-memory software code instrumentation achieved by injecting a library into the process to intercept module loads and instrument the methods in those modules with appropriate probes. The system instruments original methods to redirect execution to new methods to perform code verification tasks. By performing dynamic instrumentation, no binaries are modified on-disk, any existing code signing is preserved, and the locations from which the binaries are loaded do not matter. The system allows instrumentation to occur on any computing device, without pre-preparation by a tester or developer to install instrumented binaries. The system also does not involve gaining access to potentially sensitive locations on disk, as the binaries are modified in memory with the originals still unchanged on disk. Thus, the dynamic instrumentation system allows for more effective code analysis with less preparation and hassle for code developers.06-28-2012
20120254840THREAD SERIALIZATION AND DISABLEMENT TOOL - A computer-implemented method of performing runtime analysis on and control of a multithreaded computer program. One embodiment of the present invention can include identifying threads of a computer program to be analyzed. With a supervisor thread, execution of the identified threads can be controlled and execution of the identified threads can be monitored to determine a status of the identified threads. An indicator corresponding to the determined status of the threads can be output.10-04-2012
20100299655Determining Performance of a Software Entity - Methods, systems, and products for determining performance of a software entity running on a data processing system. The method comprises allowing extended execution of the software entity without monitoring code. The method also comprises intermittently sampling behavior data for the software entity. Intermittently sampling behavior data may be carried out by injecting monitoring code into the software entity to instrument the software entity, collecting behavior data by utilizing the monitoring code, and removing the monitoring code. The method also comprises repeatedly performing iterations of the allowing and sampling steps until collected behavior data is sufficient for diagnosing performance of the software entity. The method may further comprise analyzing the collected behavior data to diagnose performance of the software entity.11-25-2010
20100275185System and Method for High Performance Coverage Analysis - A system and method for inserting at least one instrumentation point into a program at a first location, executing the program and removing the instrumentation point from the program when the executing program reaches the instrumentation point. The system and method further recording the at least one instrumentation point in a record when the instrumentation point is removed from the program.10-28-2010
20120102470Methods, Systems, and Media for Providing Determinism in Multithreaded Programs - Methods, systems, and media for providing determinism in multithreaded programs are provided. In some embodiments, methods for providing determinism in multithreaded programs are provided, the methods comprising: instrumenting a program with: a proxy that: receives inputs to the program; and determines whether a schedule corresponding to a set of input constraints satisfied by the inputs has been memoized; and a replayer that: if it is determined that a schedule corresponding to a set of input constraints satisfied by the inputs has been memoized, processes the inputs by the program according to the schedule.04-26-2012
20120151453AUTOMATED DEBUGGING SYSTEM AND METHOD - system and method for automatically identifying a source of a run-time error in a computer system comprises a static analysis system (SAS), an instrumentation system (IS) and a post-execution analysis system (PEAS). The is arranged to generate static analysis data on computer program code (CPC) for the computer system, including information on possible behaviors of the CPC when executed. The IS is arranged to instrument the CPC by inserting marker triggers into the CPC that, generate a marker associated with each of a number of predetermined points in the CPC that would be reached during execution of the CPC. Each marker is, uniquely identifiable. The predetermined points are determined in dependence on the static analysis data. The PEASpost execution analysis system is arranged to processes data on a run-time error produced by execution of the instrumented CPC, wherein the generated markers and the static analysis data to identify the source of the run-time error.06-14-2012
20130024846Real-Time Code Coverage Results in AD-HOC Testing - Code coverage may be provided. First, coverage data and static data may be received. Next, results may be created based on the received coverage data and the received static data. The results may then be displayed.01-24-2013
20130024845Inserting Test Scripts - A method and system to automatically insert a test script into a web application is provided. A web browser is monitored to detect the navigation in the web application. The test script is automatically inserted into the web application rendered on a web browser after a navigation is detected in the web application.01-24-2013
20080244536EVALUATING STATIC ANALYSIS RESULTS USING CODE INSTRUMENTATION - A computer-implemented method for evaluating software code includes receiving from a static analysis of the software code a warning indicating a respective location in the software code of a potential bug and a possible execution path leading to the potential bug. Responsively to the warning, instrumentation is added to the code at one or more locations along the execution path. Upon executing the instrumented code, an output is generated, responsively to the instrumentation, indicating that the execution path was traversed while executing the instrumented code.10-02-2008
20080222614PREFERENTIAL PATH PROFILING - This paper describes preferential path profiling, which enables profiling a specified subset of all possible program paths with very low overhead. Preferential path profiling compactly identifies paths of interest using an array. More specifically, PPP assigns a unique and compact path index identifier to all interesting paths that can be used to index into a path array. The path array contains a second path value identifier that is used to distinguish interesting paths from other program paths This path numbering allows the implementation of preferential path profiling to use array-based counters instead of hash table-based counters for identifying paths of interest and gathering path profiles, which significantly reduces execution time and computational resource overhead during profiling.09-11-2008
20130179868System And Method For Extracting Instrumentation Relevant Inheritance Relationships For A Distributed, Inheritance Rule Based Instrumentation System - The presented enhancement of a rule based instrumentation system taking object oriented inheritance relationships into account is directed to the detection and extraction to inheritance relationships relevant for the instrumentation process. Relevant inheritance relationships which have an impact on the instrumentation process and typically only represent a small fraction of the complete inheritance relationships of a monitored application. The small size of the relevant inheritance relationships allows, for example to prepare it in advance and ship it as part of a monitoring application or to transmit inheritance information between different local instrumentation engines being part of a distributed instrumentation system.07-11-2013
20130179867Program Code Analysis System - A method, apparatus, and computer program product for analyzing program code. A set of differences is identified between a first program code and a second program code. A new program code is created having instrumented program code for the set of differences. The set of differences is analyzed using the instrumented program code in the new program code.07-11-2013
20130125096Systems and Methods for Dynamic Collection of Probe Call Sites - Systems and methods for dynamic collection of probes may employ a probe collector process that runs in conjunction with (or following) a memory garbage collection operation. In response to receiving data indicating that a probe is to be removed from an application and encountering the probe during execution of the application, the probe may be marked for removal. The probe collector process may subsequently remove the probe by replacing some or all of the probe code with NOP instructions. If the probe code for a probe marked for removal includes a call to a probe stub, the probe collector process may replace the call with a NOP instruction. In response to receiving data indicating that the removed probe should be reactivated, the NOP instruction(s) may be replaced with the previously removed probe code. Probe code for probes that are not marked for removal or that are reactivated may be executed.05-16-2013
20100287539SPECIFIC DEBUG TRACE COLLECTING - A computing system for converting software code into an executable program include an expanding preprocessor that receives software code including debug statements and expands the debug statements into conditions that include a static variable and that must be met before a trace contained in the statement is executed, the expanding preprocessor creating an expanded code output. The system also includes a replacement preprocessor coupled to the expanding preprocessor and receiving the expanded code, the replacement preprocessor forming replaced code by replacing one or more occurrences of the static variables with a unique variable name and a compiler that compiles the replacement code to create an executable.11-11-2010
20110314453REAL TIME PROFILING OF A COMPUTER SOFTWARE APPLICATION RUNNING ON PARALLEL COMPUTING RESOURCES - A method of real-time profiling a software application running on heterogeneous parallel computing resources is provided. The method may include the following steps, comprising: analyzing, in real-time, operations of a computer software application operatively associated with parallel computing resources, by executing the application on the parallel computing resources in a specified configuration of parallel computing resources usage, to yield a time-dependent profile of the computer software application in terms of usage of the parallel computing resources, wherein the profile is based on specified categories of software operations; presenting the time-dependent profile graphically and in real-time; repeating the executing with a modified configuration in response to user modifications made to the usage of the parallel computing resources, to yield an updated profile; and repeating the presenting with the updated profile, wherein at least one of the analyzing, the presenting and the repeating is executed by at least one processor.12-22-2011
20130247014MODIFYING RUN-TIME-INSTRUMENTATION CONTROLS FROM A LESSER-PRIVILEGED STATE - Embodiments of the invention relate to modifying run-time-instrumentation controls (MRIC) from a lesser-privileged state. The MRIC instruction is fetched. The MRIC instruction includes the address of a run-time-instrumentation control block (RICCB). The RICCB is fetched based on the address included in the MRIC instruction. The RICCB includes values for modifying a subset of the processor's run-time-instrumentation controls. The subset of run-time-instrumentation controls includes a runtime instrumentation program buffer current address (RCA) of a runtime instrumentation program buffer (RIB) location. The RIB holds run-time-instrumentation information of the events recognized by the processor during program execution. The values of the RICCB are loaded into the run-time-instrumentation controls. Event information is provided to the RIB based on the values that were loaded in the run-time-instrumentation control.09-19-2013
20130247012TRANSFORMATION OF A PROGRAM-EVENT-RECORDING EVENT INTO A RUN-TIME INSTRUMENTATION EVENT - Embodiments of the invention relate to transforming a program-event-recording event into a run-time instrumentation event. An aspect of the invention includes a method for transforming a program-event-recording event into a run-time instrumentation event. The method includes enabling run-time instrumentation for collecting instrumentation information of an instruction stream executing on a processor. The method also includes detecting, by the processor, a program-event-recording (PER) event, the PER event associated with the instruction stream executing on the processor. The method further includes writing a PER event record to a collection buffer as a run-time instrumentation event based on detecting the PER event, the PER event record identifying the PER event.09-19-2013
20130247011TRANSFORMATION OF A PROGRAM-EVENT-RECORDING EVENT INTO A RUN-TIME INSTRUMENTATION EVENT - Embodiments of the invention relate to transforming a program-event-recording event into a run-time instrumentation event. An aspect of the invention includes enabling run-time instrumentation for collecting instrumentation information of an instruction stream executing on a processor. Detecting is performed, by the processor, of a program-event-recording (PER) event, the PER event associated with the instruction stream executing on the processor. A PER event record is written to a collection buffer as a run-time instrumentation event based on detecting the PER event, the PER event record identifying the PER event.09-19-2013
20130247010RUN-TIME INSTRUMENTATION SAMPLING IN TRANSACTIONAL-EXECUTION MODE - Embodiments of the invention relate to implementing run-time instrumentation sampling in transactional-execution mode. An aspect of the invention includes run time instrumentation sampling in transactional execution mode. The method includes determining, by a processor, that the processor is configured to execute instructions of an instruction stream in a transactional-execution mode, the instructions defining a transaction. Completion of storage operations of the instructions is interlocked to prevent instruction-directed storage until completion of the transaction. A sample point is recognized during execution of the instructions while in the transactional-execution mode. Run-time-instrumentation-directed storing is performed, upon successful completion of the transaction, run-time instrumentation information obtained at the sample point.09-19-2013
20130247009RUN-TIME INSTRUMENTATION INDIRECT SAMPLING BY INSTRUCTION OPERATION CODE - Embodiments of the invention relate to implementing run-time instrumentation indirect sampling by instruction operation code. An aspect of the invention includes reading sample-point instruction operation codes from a sample-point instruction array, and comparing, by a processor, the sample-point instruction operation codes to an operation code of an instruction from an instruction stream executing on the processor. A sample point is recognized upon execution of the instruction with the operation code matching one of the sample-point instruction operation codes. The run-time instrumentation information is obtained from the sample point. The run-time instrumentation information is stored in a run-time instrumentation program buffer as a reporting group.09-19-2013
20130247008HARDWARE BASED RUN-TIME INSTRUMENTATION FACILITY FOR MANAGED RUN-TIMES - Embodiments of the invention relate to performing run-time instrumentation. Run-time instrumentation is captured, by a processor, based on an instruction stream of instructions of an application program executing on the processor. The capturing includes storing the run-time instrumentation data in a collection buffer of the processor. A run-time instrumentation sample point trigger is detected by the processor. Contents of the collection buffer are copied into a program buffer as a reporting group based on detecting the run-time instrumentation sample point trigger. The program buffer is located in main storage in an address space that is accessible by the application program.09-19-2013
20130247013CONTROLLING OPERATION OF A RUN-TIME INSTRUMENTATION FACILITY FROM A LESSER-PRIVILEGED STATE - Embodiments of the invention relate to enabling and disabling execution of a run-time instrumentation facility. An instruction for execution by the processor in a lesser privileged state is fetched by the processor. It is determined, by the processor, that the run-time instrumentation facility permits execution of the instruction in the lesser-privileged state and that controls associated with the run-time instrumentation facility are valid. The run-time instrumentation facility is disabled based on the instruction being a run-time instrumentation facility off (RIOFF) instruction. The disabling includes updating a bit in a program status word (PSW) of the processor to indicate that run-time instrumentation data should not be captured by the processor. The run-time instrumentation facility is enabled based on the instruction being a run-time instrumentation facility on (RION) instruction. The enabling includes updating the bit in the PSW to indicate that run-time instrumentation data should be captured by the processor.09-19-2013
20130254749DYNAMICALLY PROVIDING APPLICATION ANALYTIC INFORMATION - Methods and systems for dynamically providing application analytic information are provided herein. The method includes inserting instrumentation points into an application file via an application analytic service and dynamically determining desired instrumentation points from which to collect application analytic data. The method also includes receiving, at the application analytic service, the application analytic data corresponding to the desired instrumentation points and analyzing the application analytic data to generate application analytic information. The method further includes sending the application analytic information to a client computing device.09-26-2013

Patent applications in class Including instrumentation and profiling