Abstract: A binary rewriter that can provide complete code coverage without relocation information is provided, together with a method of performing such rewriting. The method can include processing a binary file as an original binary file. The method can also include disassembling the binary file to provide a disassembled binary file. The method can further include rewriting the disassembled binary file without relocation information to provide a rewritten binary file. The rewriting can provide a physical transformation in a recording medium relative to the binary file in the recording medium prior to the rewriting. The processing the binary file, disassembling the binary file, and rewriting the disassembled binary file can be performed by a particular machine.

Abstract: The construction or use of a hierarchical time tree that represents an execution time of a program. To construct the hierarchical time tree, the time frame corresponding to the root node is the execution time during which the plurality of call stack samples were gathered from the program. Beginning at the root node, and proceeding recursively, each node is then populated in a manner that all of the call stacks for a given time period need not be accessed in order to provide a report regarding the given time period.

Abstract: In an embodiment, a test installer is executed that includes woven advice located at join points. The join points are associated with methods in the test installer. When the advice in the test installer is executed, the advice saves identifiers of the associated join points and times of execution. Subsets of the join points are assigned to installation options. Each installation option causes a production installer to execute a combination of methods. In response to receiving an installation option, advice is woven into the production installer at the join points specified by the assigned subset. When the advice in the production installer is executed, the advice reports its join point identifier, and the production installer presents completion progress status based on the time that was saved for the join point identifier during execution of the test installer. In this way, progress status may be provided during the installation of programs.

Abstract: Tracing within a processing environment is controlled. Trace directives are automatically included within code being compiled in order to control where one or more traces begin and end within the code. The trace directives provide a framework for mapping traces to well understood boundaries of the code.

Abstract: 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 type of node marking and 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.

Abstract: Some embodiments of the present invention provide techniques and systems for optimizing bounds-checking During operation, the system can receive one or more instructions which when executed evaluate a first expression whose value is required to be between a lower bound expression's value and an upper bound expression's value, such that at least one of the following three values is not determinable before execution: the first expression's value, the lower bound expression's value, and the upper bound expression's value. Next, the system can use computer algebra to determine whether the first expression's value is guaranteed to be between the lower bound expression's value and the upper bound expression's value. If the system determines that the first expression's value is not guaranteed to be between the lower bound expression's value and the upper bound expression's value, the system can add bounds-checking instructions to the one or more instructions.

Abstract: An information handling system includes a memory, a processor, and an instruction tracking unit. The processor executes program code and, while the program code executes, the instruction tracking unit decodes a multi-purpose no-op instruction within the program code. In turn, the instruction tracking unit sends an interrupt to the processor, which invokes a profiling module to collect and store profiling data in a profiling buffer.

Abstract: Generally, the present disclosure provides a system and method for mapping registers from a system with more registers to a system with fewer registers. Regions may be formed that include one or more blocks of code with relatively frequent register accesses. The most frequently accessed source registers may be mapped to target registers. Each block in the region may be bounded by a prologue and at least one epilogue. The prologue may be configured to implement register mapping and the epilogue(s) may be configured to manage program flow from a block in the region to another block in the region or to a block not in the region.

Abstract: Application profiles for applications stored on the endpoint are defined. An application profile identifies components on the endpoint associated with an application with which the application profile is associated. Applications on the endpoint accessed by a user to perform a task are monitored. A task profile associated with the task is created and stored, the task profile associated with the application profiles for the applications accessed by the user to perform the task.

Abstract: Access is obtained to an input object-oriented computer program. In the input object-oriented computer program, semantically equivalent objects are identified, which exist in different memory locations. If at least one of: a number of occurrences for the semantically equivalent objects exceeds a first threshold value, the threshold value being at least two; and a number of equality tests on the semantically equivalent objects exceeds a second threshold value, then a further step includes identifying an application program interface to reduce the semantically equivalent objects to a single object in a single memory location.

Abstract: A system for generic, run-time adaptive placement of byte code instrumentation takes into account object oriented inheritance relationships that are stored in an inheritance repository. The inheritance repository, which mirrors the structure of the monitored application, is created at run-time and is 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 with instrumentation placement at application load-time or run-time and persists between application runs to enable dedicated adaptation runs to create the repository.

Abstract: A system and method for automatically analyzing virtual machine bytecode of a software application and adding additional bytecode operable to determine information regarding network communication performed by the software application are described. According to one embodiment of the method, program code of a software application may be received, wherein the program code includes bytecode for a virtual machine. The bytecode may be automatically analyzed to detect network communication functionality. The method may operate to automatically add additional bytecode to the bytecode of the software application, where the added bytecode is operable to determine information regarding the network communication.

Abstract: A method for tailored compiler optimization is provided. The method includes extracting kernels from an application program, performance tuning the kernels to determine a tailored optimization strategy for each of the kernels, the tailored optimization strategy different than a default optimization strategy of a compiler for each of the kernels, and annotating the application program, using a computer, to identify the tailored optimization strategy determined for each of the kernels. In an embodiment, the method also includes the design and implementation for adjusting a compiler to customize optimization strategies for different kernels.

Abstract: Memory management for object oriented applications during run time includes loading an object oriented application into a computer memory. The object oriented application includes a plurality of nodes in a classification tree, the nodes including key value pairs. The nodes are aggregated in the classification tree by a computer. The aggregating includes eliminating redundant keys and creating a composite node. The composite node is loaded into the computer memory. The plurality of nodes in the classification tree are removed from the computer memory in response to loading the composite node into the computer memory.

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

Abstract: The information processing system of the present invention includes a profile information collection unit for storing access-related profile information in response to detecting access to an object set as a profile target on the basis of the sampling frequency for each class or object allocation site during the execution of a program, and a sampling frequency updating unit for calculating the allocation percentage of an object having properties used in the optimization of the program at each class or object allocation site on the basis of profile information, and for reducing the sampling frequency regarding a class or object allocation site in which the calculated percentage is below a predetermined threshold value.

Abstract: Techniques for handling dependency conditions, including evil twin conditions, are disclosed herein. An instruction may designate a source register comprising two portions. The source register may be a double-precision register and its two portions may be single-precision portions, each specified as destinations by two other single-precision instructions. Execution of these two single-precision instructions, especially on a register renaming machine, may result in the appropriate values for the two portions of the source register being stored in different physical locations, which can complicate execution of an instruction stream. In response to detecting a potential dependency, one or more instructions may be inserted in an instruction stream to enable the appropriate values to be stored within one physical double precision register, eliminating an actual or potential evil twin dependency.

Abstract: A method for compiler-guided optimization of MapReduce type applications that includes applying transformations and optimizations to Java bytecode of an original application by an instrumenter which carries out static analysis to determine application properties depending on the optimization being performed and provides an output of optimized Java bytecode, and executing the application and analyzing generated trace and feeds information back into the instrumenter by a trace analyzer, the trace analyzer and instrumenter invoking each other iteratively and exchanging information through files.

Abstract: Generating an application software library comprises: a static analyser processing a binary input library to identify one or more locations in the binary input library which satisfy a semantic analysis condition; inserting metadata into the binary input library at the one or more locations which satisfy the semantic analysis condition; and linking the binary input library with a binary aspect library to generate the application software library, wherein the binary aspect library includes an aspect definition using the metadata.

Abstract: An apparatus and program product utilize an inheritance breakpoint to assist in debugging an object-oriented computer program having a method identified in a base class or interface and implemented by at least one method implementation in another class. Creation of an inheritance breakpoint for a particular method responsive to a user request typically results in the automated generation of a breakpoint for all or a subset of the implementations of that method, often freeing a user from having to manually determine what particular implementation(s) implement that method. In many environments, the automated generation of implementation breakpoints may be performed during initial loading of classes within which such implementations may be defined.

Abstract: An apparatus, program product and method optimize the operation of a massively parallel computer system by, in part, receiving actual performance data concerning an application executed by the plurality of interconnected nodes, and analyzing the actual performance data to identify an actual performance pattern. A desired performance pattern may be determined for the application, and an algorithm may be selected from among a plurality of algorithms stored within a memory, the algorithm being configured to achieve the desired performance pattern based on the actual performance data.

Abstract: Functionality from an object file can be incorporated into an already existing binary file. Functions from the object file can be intelligently inserted into the binary file with the guidance of control flow analysis of both the binary file and the object file. Symbols not defined in the symbol table of the binary file are added to the symbol table of the binary file. When symbols of the object file and the binary file overlap, then priority is given to the object file symbol definitions. The ability to incorporate functionality from an object file into an existing binary file reduces logistical overhead and provides flexibility in code development and maintenance.

Abstract: A device generates code with a technical computing environment (TCE) based on a model and information associated with a target processor, registers an algorithm with the TCE, automatically sets optimization parameters applied during generation of the code based on the algorithm, executes the generated code, receives feedback based on execution of the generated code, and uses the feedback to automatically update the optimization parameters and to automatically regenerate the code with the TCE until an optimal code is achieved for the target processor.

Abstract: A computer-implemented process for creating a packed data object, the computer-implemented process comprising providing instrumentation to an enhanced runtime by an enhanced compiler for a computer executable program portion, detecting a special class in the computer executable program portion by the enhanced runtime, creating an internal representation of a packed data object header using the instrumentation, calculating a size of elements for a packed data object associated with the computer executable program portion, determining a type of packed data object using information in the packed data object header, and responsive to a determination that the type of packed data object is an on-heap packed data object, storing the packed data object header and associated packed data object data together for the packed data object in a memory heap.

Abstract: This document discusses, among other things, a system and method computing the shortest path expression in a loop having a plurality of expressions. Candidate expressions in the loop are identified and partitioned into sets. A cost matrix is computed as a function of the sets. Paths are found through the cost matrix and, if there are cycles in the paths, the cycles are broken. One or more shortest path expressions are generated as a function of the paths and one or more of the expressions in the loop are replaced with the shortest path expressions.

Abstract: A mechanism for minimizing effective memory latency without unnecessary cost through fine-grained software-directed data prefetching using integrated high-level and low-level code analysis and optimizations is provided. The mechanism identifies and classifies streams, identifies data that is most likely to incur a cache miss, exploits effective hardware prefetching to determine the proper number of streams to be prefetched, exploits effective data prefetching on different types of streams in order to eliminate redundant prefetching and avoid cache pollution, and uses high-level transformations with integrated lower level cost analysis in the instruction scheduler to schedule prefetch instructions effectively.

Abstract: A system and associated method for changing the initial size of a variable where intermediate code contains a static method class which in turn contains the initial size of variable. Comparing a statistic with the initial size of the variable, the statistic being derived from all current instances of the variable contained in located in dynamic memory, the comparing being performed in response to an event having occurred. Then modifying the initial size of the variable located in the intermediate code. The modification being in such a way as to change the initial size of variable in dependence of the statistic and all current instances of the variable located in the dynamic memory. Finally, repeating the comparing and changing steps for all variables contained in the dynamic memory.

Abstract: A function may be memoized when a side effect is a read only side effect. Provided that the read only side effect does not mutate a memory object, the side effect may be considered as an input to a function for purity and memoization analysis. When a read only side effect may be encountered during memoization analysis, the read only side effect may be treated as an input to a function for memoization analysis. In some cases, such side effects may enable an impure function to behave as a pure function for the purposes of memoization.

Abstract: This invention relates to a method, computer readable medium, and apparatus for identifying one or more problematic loops in an application. This invention provides a Directed Acyclic Graph or DAG representation of structure of one or more loops in the application by performing a static and a dynamic analysis of the application source code and depicts the loop information as LoopID, loop weight, total loop iteration, average loop iteration, total loop iteration time, average loop iteration time and embedded vector size. This aids a programmer to concentrate on problematic loops in the application and analyze them further for potential parallelism.

Abstract: A function may be selected for memoization when the function indicates that memoization may result in a performance improvement. Impure functions may be identified and ranked based on operational data, which may include length of execution. A function may be selected from a ranked list and analyzed for memoization. The memoization analysis may include side effect analysis and consistency analysis. In some cases, the optimization process may perform optimization on one function at a time so as to not overburden a running system.

Abstract: A dual evaluation mode method for use with computer software that includes the acts of determining, for certain functions and expressions within input computer code, whether each function and expression may have any recursive dependencies, generating eager evaluation mode executable code for one or more elements of the input computer code based on the act of determining and providing both eager evaluation mode executable code and non-eager evaluation mode executable code to runtime software that supports both eager and non-eager evaluation modes.

Abstract: A high level programming language provides a map transformation that takes a data parallel algorithm and a set of one or more input indexable types as arguments. The map transformation applies the data parallel algorithm to the set of input indexable types to generate an output indexable type, and returns the output indexable type. The map transformation may be used to fuse one or more data parallel algorithms with another data parallel algorithm.

Abstract: A computer implemented method, data processing system, and computer program product for Java class automatic deployment using byte code instrumentation technology. One or more classloaders are instrumented with byte code instrumentation code such that a class loading event is received when a class is loaded. If a determination is made that new byte code instrumentation code needs to be loaded with the loaded class, candidate classloaders that load import classes of the new byte code instrumentation code are determined. A correct classloader from the candidate classloaders to load the new byte code instrumentation code is calculated. The correct classloader is instrumented to have an extended classpath, wherein the new byte code instrumentation code is inserted into the extended classpath of the correct classloader. The class is loaded from the extended classpath and original classpath of the correct classloader.

Abstract: Bounding resource consumption of code that processes recursive data structures and collections includes making use of quantitative functions (based on user input) that are associated with a tuple of data-structures and whose semantics is specified by describing the effect of various data-structure methods on the relevant quantitative functions. Counter variables are incorporated into source code to count loop iterations (and number of recursive procedure call invocations). Relevant quantitative functions are incorporated into the source code to allow computation of invariants (and hence bounds) on the incorporated counter variables in terms of the quantitative functions.

Abstract: Integrated trace selection and profiling in dynamic optimizers may include selecting a trace head based on profile of basic blocks that are executed. The basic blocks executed from the trace head may be recorded as a trace. The trace may be added to a trace nursery in non-compiled state. The trace may be interpreted and profiled until the trace matures. Under a profiling mode, path sensitive runtime information such as values, types, targets of call-sites, and exit frequencies can be collected. The trace may be moved out of the nursery to a compilation queue in response to determining that the trace has matured based on an execution count of the profiled trace.

Abstract: Testing a computer software application by identifying a sink in the computer software application, identifying a source associated with the sink in the application, identifying an entry point associated with the source in the application, where the source is configured to receive input provided externally to the application via the entry point, determining a sink type represented by the sink, and providing to a testing application information identifying the entry point and in association with the sink type.

Abstract: Traditional feedback-directed optimization (FDO) is not widely used due to the significant computational overhead involved in using instrumented binaries. The described embodiments provide methods that eliminate the need for instrumented binaries by permitting the conversion of hardware-event sampling information into edge frequencies usable by FDO compilers. Some advantages include: the ability to collect feedback data on production systems; the ability to perform FDO on the OS kernel; and the ability to avoid disrupting timing paths from instrumented binaries.

Abstract: Methods and systems for computer program optimization utilize function cloning in program code, such as post-linked code. Each function call is directed to a different cloned version of the called function. Conventional profiling methods such as hardware event sampling, basic block profiling, and edge profiling may then be applied to the modified program code to obtain call path-based, clone-specific profile data. The profile data can be further exploited to optimize the program code.

Abstract: A set of helper thread binaries is created to retrieve data used by a set of main thread binaries. If executing a portion of the set of helper thread binaries results in the retrieval of data needed by the set of main thread binaries, then that retrieved data is utilized by the set of main thread binaries.

Abstract: A system and method for debugging a computer program by using a call graph. A call graph that represents trace events during execution of a debuggee program may be used as input to a system that enables a user to debug the debuggee program. Mechanisms facilitate conditionally forming clusters of event nodes, a cluster indicative of multiple event nodes corresponding to an execution of a source language statement. During a debugging session, in response to a command to perform a step operation, the nodes of a cluster are processed together so that a step corresponds to multiple events if the multiple events correspond to a single source language statement. A mechanism for inspecting variables is provided. Variable values may be selectively propagated and provided based on the call graph and a static control flow analysis of the debuggee program.

Abstract: There is provided an autonomic software system and method for normalizing a profile collected for an executing application to account for one or more actions applied to the executing application after the profile was collected, comprising: predicting an impact of applying the one or more actions to the executing application by utilizing the profile and the one or more actions; and adjusting the profile to form a normalized profile according to the predicted impact. A plurality of different a profile consumers, such as, a phase shift detector, an action evaluator as well as a normalizing controller, may utilize the normalized profile to improve the behavior of the executing application. In addition, online visualization tools may be implemented to graphically depict the normalized profiles, as well as differences between the collected profiles and the normalized profiles.

Abstract: Disclosed is a software testing system operative to test a software application, for example during runtime. There may be provided an apparatus for at least partially isolating, from within the software application, at least one highly coupled software component which performs a given function. Isolation may be performed by introducing, prior to execution, code elements for runtime access of application points associated with the at least one highly coupled software component. There may also be provided apparatus for removing or replacing a behavior of at least said at least partially isolated highly coupled software component during runtime.

Abstract: A linker generates a simulator-use executable format program from a pre-conversion object program and a simulator-use object program. A simulator executes the simulator-use object program and acquires branch trace information. A binary program converting tool, based on the branch trace information and a branch penalty table, generates a post-conversion object program having a rewritten branching prediction bit of the pre-conversion object program. Another linker generates an actual-machine-use executable format program from the post-conversion object program and an actual-machine-use object program.

Abstract: Disclosed are a method and system for optimized, dynamic data-dependent program execution. The disclosed system comprises a statistics computer which computes statistics of the incoming data at the current time instant, where the said statistics include the probability distribution of the incoming data, the probability distribution over program modules induced by the incoming data, the probability distribution induced over program outputs by the incoming data, and the time-complexity of each program module for the incoming data, wherein the said statistics are computed on as a function of current and past data, and previously computed statistics; a plurality of alternative execution path orders designed prior to run-time by the use of an appropriate source code; a source code selector which selects one of the execution path orders as a function of the statistics computed by the statistics computer; a complexity measurement which measures the time-complexity of the currently selected execution path-order.

Abstract: A target application is automatically tuned. A list of solutions for identified performance bottlenecks in a target application is retrieved from a storage device. A plurality of modules is executed to compute specific parameters for solutions contained in the list of solutions. A list of modification commands associated with specific parameters computed by the plurality of modules is generated. The list of modification commands associated with the specific parameters is appended to a command sequence list. The list of modification commands is implemented in the target application. Specific source code regions corresponding to the identified performance bottlenecks in the target application are automatically tuned using the implemented list of modification commands. Then, the tuned target application is stored in the storage device.

Abstract: Embodiments of the invention provide techniques for presenting energy consumption information in an IDE tool. In one embodiment, the IDE tool may be configured to determine energy requirements associated with specific elements of the source code, and to present graphical indications of energy requirements along with those code elements. Such energy requirements may be determined by matching code elements to a stored data structure describing energy requirements for executing various code elements. The stored data may be based on predefined standards, and/or may be based on historical measurements of energy consumption during prior instances of executing code elements on a target computer system. Additionally, developers may specify priority for compiling portions of source code, according to desired energy requirements.

Abstract: 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.

Abstract: A computer implemented method, apparatus, and computer program product for processing events. Events occurring during execution of an application are monitored to form monitored events. A plurality of sequences of method types and transition types from the monitored events are identified to form an identified plurality of sequences of method types and transitions types. Overhead compensation values are identified for the identified plurality of sequences of method types and transitions types to form identified overhead compensation values. Observed metrics for the monitored events are adjusted using the identified overhead compensation values.

Abstract: A system and method for monitoring the performance and execution flow of a target application and generating a corresponding data model are provided. The system and method comprise attaching to a thread or process of a target application and tracking the execution of subroutines using instrumentation commands. Data representing the execution flow of the various subroutines, subroutine calls, and their performance is gathered and used to generate data models representing the threads and processes of the application. The data models are optionally merged and/or pruned. A visualization of the data models is generated indicating relevant points of interest within the target application's execution flow.

Abstract: A system and method for automatic code generation includes parsing source code in a source program to automatically generate reliability, accessibility and serviceability (RAS) code in response to the source code. The automatically generated code is executed in a check in stage. All, a portion or none of the automatically generated code is selectively removed during a check out stage to keep the source program clean and focused.