International Business Machines Corporation

Marina Biberstein

Andre Heilper

Eitan D Farchi

Shmuel Ur

Bilha Mendelson

Shay Bushinsky

Sara Porat

Yarden Nir

Yuval Harel

Javier Merino Cacho

Larry Koved

Javier Merino

Systems and methods for enhancing performance in a multithreaded computing system are provided. The method comprises receiving a plurality of values associated with a performance characteristic common to a plurality of threads; clusterizing the plurality of threads based on the performance characteristic; analyzing an inter-thread communication between the plurality of threads for identifying a plurality of threads adversely affecting the performance of different parts of the multithreaded program; calculating a performance factor corresponding to the performance characteristic to determine a type of performance improvement activity to be performed on the plurality of threads.

Performance analysis system for analyzing inter-thread communications to enhance performance in multithreaded system

Expert system may utilize multiple metrics to estimate whether a performance improvement activity has a potential to improve performance in respect to a predetermined performance metric. The multiple metrics may be propagated based on whether or not they may be affected by the activity and based on an associated value that may take into account the current value of the metric. An Index Propagation Graph may be further utilized to represent a propagation function which may propagate the potential of improvement of each metric in respect to the predetermined performance metric.

Identifying opportunities to improve multiprocess system performance

A tool is provided for modifying the code of a multi-threaded computer program undergoing testing. The program executes in an environment that has a governing memory model. It is assumed that there is a global heap and a thread-local heap, which are synchronized from time to time. The modifications are of two types: (1) code instructions are reordered while remaining in compliance with the memory model; and (2) thread-local variables are added to functions, together with inserted heap synchronizing instructions. The modified programs are then used by a test generator to prepare test cases for execution. The modifications have the effect of changing the interleavings that occur among different threads, and increase the likelihood of exposing flaws that may become evident under different memory models.

Using code motion and write and read delays to increase the probability of bug detection in concurrent systems

A method for testing a computer program that includes software code arranged to be executed in multiple threads, including at least a first thread and one or more other threads. The method includes identifying an output statement in the first thread, running the software code so as to generate an output due to the output statement, and intervening in the program so that when the program is run, execution of the first thread is blocked prior to the output statement while the one or more other threads continue to execute. The output generated after intervening in the program is examined in order to detect a fault in the program.

Testing parallel applications using code instrumentation

A system and method to synchronize independent local clocks in multi-core processing system are disclosed. A shared counter or a shared memory/file is provided to establish a partial happened-before relationship (e&#x3c;ein the happened-before order if we know that the event ehappened before the event e) and a synchronizer device is utilized to generate a global time of events in threads or processes. The synchronizer device estimates each clock's start time and approximates elapsed time between events in threads or processes by executing an all-pair shortest-path algorithm.

Synchronization of independent clocks

A method for determining a required solution subset from a set of solutions for eliminating a computer program execution error is provided. The method includes selecting a first candidate solution subset from a set of solutions for a computer program that produces an error when executed, wherein each of the solutions represents a different proposed modification of the program for eliminating the execution error, applying the first candidate solution subset to the computer program, thereby creating a first version of the program, selecting a second candidate solution subset from the set of solutions, applying the second candidate solution subset to the program, thereby creating a second version of the program, executing the first and second program versions to determine whether either of the executed program versions produces the error, adding the difference between the first and second candidate solution subsets to a required solution subset, when one of the executed program versions produces the error, and the other of the executed program versions does not produce the error, applying the required solution subset to the program, thereby creating a third version of the program, executing the third program version to determine whether the executed third version of the program produces the error and, if the third version of the program produces the error, repeating the above steps for different candidate solution subsets until the third version of the program does not produce the error.

Determining minimal sets of bug solutions for a computer program

A system and method for detecting the mutability of fields and classes in an arbitrary program component written in an object oriented programming language is disclosed. A variable is considered to be mutable if a new value is stored into it, as well as if any of its reachable variables are mutable. The system and method uses a static analysis algorithm which can be applied to any software component rather than whole programs. The analysis classifies fields and classes as either mutable or immutable. In order to facilitate open-world analysis, the algorithm identifies situations that expose variables to potential modification by code outside the component, as well as situations where variables are modified by the analyzed code. An implementation of the analysis is presented which focuses on detecting mutability of class variables, so as to avoid isolation problems. The implementation incorporates intra- and inter-procedural data-flow analyses and is shown to be highly scalable. Experimental results demonstrate the effectiveness of the algorithms.

Growing community of inventors

Haifa, Israel

Marina Biberstein