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

Abstract: Applications are optimized using source code patterns and performance analysis. Patterns of inefficiently coded statements are stored, and source code that includes program statements are identified. The program statements are compared with the patterns to identify program statements that are inefficiently coded. An execution of a compiled version of the source code is monitored to identify program statements that cause performance issues The identified program statements that are inefficiently coded are compared with the identified program statements that cause performance issues to determine program statements that are inefficiently coded and cause performance issues.

Abstract: A system for reporting information about how selected components of an operating system are used by applications on a computing device. A manifest of components is provided from a management server to a computing device. The manifest specifies components of the operating system for which usage information is to be collected. The computing device surveys applications for calls to the components specified in the manifest. Surveys may be performed by static scanning and/or dynamic monitoring. In static scanning, application files are scanned for keyword strings specified in the manifest. Keyword string matches are recorded to a log file. In dynamic monitoring, calls from executing applications to components specified by the manifest are identified and logged. A report is generated from the log and sent to the management server. The management server then aggregates and analyzes reports from multiple computing devices to enable developers to assess how the components are being used.

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

Abstract: In one general aspect, a computer-based software testing method is disclosed that includes presenting to a user an interactive visual user interface of an application under test that includes a plurality of user interface controls, with each of the presented user interface controls having a predefined native interaction mode. The method also includes intercepting normative pointing-device-based user interaction with each of a plurality of the user interface controls, with the normative pointing-device-based user interaction mode being different from the native interaction mode. Interface definitions are built for the application based on results of the steps of intercepting for the plurality of interface controls.

Abstract: A partition-based method for diagnosing memory leaks in Java systems, comprising dividing heap memory of a Java virtual machine into a plurality of partitions based on a partition plan, wherein each partition has at least one partition owner; monitoring the status of the respective partitions to determine whether there is a partition in which the memory space is exhausted; and if there is a partition in which the memory space is exhausted, determining that the memory leak may occur in the partition and analyzing the partition to obtain leaked objects and objects related to the leaked objects. The present invention also provides a partition-based apparatus for diagnosing memory leak in Java systems.

Abstract: A method includes determining, as part of a static analysis of a program, links between functions in the program and performing, as part of the static analysis, string analysis on strings used in the program to determine additional links between the functions in the program. The method further includes outputting, as part of the static analysis, indications of at least the links between the functions and the additional links between the functions. Apparatus, computer programs, and program products are also disclosed.

Abstract: An apparatus and computer program product which are configured for determining, as part of a static analysis of a program, links between functions in the program and performing, as part of the static analysis, string analysis on strings used in the program to determine additional links between the functions in the program. The apparatus and computer program product are further configured for outputting, as part of the static analysis, indications of at least the links between the functions and the additional links between the functions.

Abstract: Various technologies and techniques are disclosed for using a command interpreter at design time of a software application. A command interpreter can be used to design and test the functionality of an application at design time. The command interpreter allows a user to identify a command to execute for a selected object at design time of an application being developed within a software application design environment. The command interpreter causes the identified command to be executed. A selected object can be sent from a visual tree to the command interpreter. The command interpreter receives the object sent from the visual tree and assigns a designated object name for referencing the object in the command interpreter. The designated object name is displayed within the command interpreter to allow a user to have an abbreviated way of issuing one or more commands for the object from the command interpreter.

Abstract: A method for verifying software includes determining an initialization path condition of a received software verification job, determining a termination path condition of a computing node, and initializing the execution of the received software verification job on the computing node based on the initialization path condition and the termination path condition. The initialization path condition includes a sequence of program predicates for reaching a starting state of software to be verified. The received software verification job includes an indication of a portion of the software to be verified. The termination path condition includes an indication of the last state reached during the execution of a previous software verification job on the computing node. The computing node is assigned to execute the received software verification job.

Abstract: A system and method for debugging a running process of an application or component are disclosed. A debugging agent runs one or more templates. Each template is configured with a breakpoint set defined in debugging code for stopping execution of the running process according to one or more breakpoints. One or more debugging clients each includes a user interface for defining at least one of the one or more templates. Each debugging client is selectable to receive debugging information of the running process based on the breakpoint set.

Abstract: A method disclosed herein provides for receiving information relating to an event that occurred while processing server request from a compiled code snippet inserted into a compiled computer program, calculating diagnostic information relating to execution of the server request based on the received information, and providing the diagnostic information. Alternatively, a computer-readable medium, storing a set of instructions, is provided for, the instructions, when executed by a processor perform a method including, while a server request is being executed, receiving information from a compiled code snippet, in inserted into a compiled computer program, the received information relating to a thread starting to process the server request.

Abstract: Generation of cached representations of an encoded package profile. A physical or virtual client machine can host a set of installed software packages, including operating system, application, and/or other software. A package manager installed on the client machine can track the installed package complement, and updates available for those packages. The package manager can be configured to capture attributes of the set of installed packages, and generate an encoded identification of the installed packages using a hash or other algorithm. The encoded identification can be transmitted to one or more package servers or other management platform. The package server(s) can receive and decode the identifier, and insert that identifier and other package-related data into a local package cache. The package server(s) or other platform can configure package update or other activity using the cached representation of package profiles for one or more client machines.

Abstract: A method of developing a tracing solution for the execution of blocks of computer code. The method comprises representing each block of code of an initial tracing solution as a vertex on an initial tracing solution graph. The vertices on the initial tracing solution graph constitute an initial set of vertices. The method further comprises checking whether there are any redundant vertices in the initial set of vertices. Redundant vertices are vertices not needed for a tracing solution. If there are any redundant vertices in the initial set of vertices, one or more of the redundant vertices is eliminated from the initial set of vertices, thereby deriving a reduced set of vertices.

Abstract: A system of testing software is provided. The system comprises a first hardware system having hardware components to execute a first version of the software, and additionally comprises a second hardware system having hardware components to execute a second version of the software at approximately the same time as the hardware components of the first hardware system execute the first version of the software. Here, the hardware components of the first hardware system are essentially equal to the hardware components of the second hardware system. In addition, the system includes a simulator coupled to the first hardware system and the second hardware system through the same network. This simulator comprises an agent to input a substantially same amount and a substantially same type of input data into the first and second hardware systems for execution by the first and second versions, respectively.

Abstract: A method for grouping algorithms included in a program into groups and thus for assisting in analyzing the program. The method includes the steps of: converting each of the algorithms into a directed graph; judging, as to each representative directed graph stored in a storage unit of a computer system, whether or not the directed graph obtained by the conversion is similar to the representative directed graph; and determining a group to which the directed graph obtained by the conversion belongs from among groups stored in the storage unit in accordance with the similarity judgment. A computer system for performing the above method and a computer program for causing a computer system to perform the above method are also described.

Abstract: A software system is disclosed which facilitates the process of tracing the execution paths of a program, called a client or application. Trace data corresponding to selected system resources that interact with the execution of the application is collected during the tracing operation and stored in an application signature. A computer system user can generate trace options, trace the application, and compare the application signature to a known software configuration. The application signature is compared to a reference signature created by tracing the execution of the application on a system with the known software configuration. In another embodiment, the application signature is compared to a static configuration of a reference computer.

Abstract: A method of creating constraints for use with object code insertion technology can include deriving an A-representation and a B-representation of values produced by execution of instructions of a portion of object code, wherein prior to object code insertion the A-representation and the B-representation of a value produced by same instruction(s) are equivalent. The method further can include identifying equalities between A-representations of values produced by different instructions and determining constraints from the identified equalities using B-representations, where the constraints are observed after object code insertion.

Abstract: A method for a hybrid code signature including executing, via a processor, an application, the executing comprising executing a root instruction of the application; profiling, via the processor, the executing of the application, the profiling comprising storing a reference signature; determining, via the processor, a working signature of instructions executed subsequent to the executing of the root instruction, the determining comprising implementing a hashing function of the instructions in response to storing the reference signature; tracking the updating of the working signature by storing a value in a counter; and updating continuously, via the processor, the working signature with the hashing function while at least the working signature does not match the reference signature.

Abstract: Coverage analysis may be performed using reverse time. The coverage analysis may be based on last hit data. The last hit data may comprise a timestamp indicating a last time in which a coverage event was covered. Utilizing last hit data instead of first hit data as is known in the art enables distinction between coverage goals that were never covered and coverage goals that were not covered lately.

Abstract: A technique for providing environmental impact information associated with code includes determining, based on execution of the code on a computer system, an environmental impact of a code execution sequence included in the code. A section of the code that is associated with the code execution sequence is then annotated with environmental impact information associated with the environmental impact of the code execution sequence.

Abstract: A method is presented for recording and injecting a fault event during execution of a computer program. The method may include detecting a method call event during execution of the program, incrementing a counter to produce a counter value, and determining, based on a program execution state, a fault event to be generated. The fault event may be associated with a fault event type. The fault event type and the counter value may be stored, and the fault event may be generated. A second method call event may be detected during execution of the program and a second counter may be incremented, producing a second counter value. A previously-generated fault event associated with a counter value matching the second counter value may be identified, and the previously-generated fault event may be generated.

Abstract: A function's purity may be estimated by comparing a new input vector to previously analyzed input vectors. When a new input vector is within a confidence boundary, the new input vector may be treated as a known vector, even when that vector has not been evaluated. The input vector may reflect the input parameters passed to a function, and the function may be analyzed to determine whether to memoize with the input vector. The function may be a function that behaves as a pure function in some circumstances and with some input vectors, but not with others. By memoizing the function when possible, the function may be executed much faster, thereby improving performance.

Abstract: A system that facilitates computing a symbolic bound with respect to a procedure that is executable by a processor on a computing device is described herein. The system includes a transition system generator component that receives the procedure and computes a disjunctive transition system for a control location in the procedure. A compute bound component computes a bound for the transition system, wherein the bound is expressed in terms of inputs to the transition system. The system further includes a translator component that translates the bound computed by the compute bound component such that the bound is expressed in terms of inputs to the procedure.

Abstract: A sampling based DBR framework which leverages a separate core for program analysis. The framework includes a hardware performance monitor, a DBR service that executes as a separate process and a lightweight DBR agent that executes within a client process. The DBR service aggregates samples from the hardware performance monitor, performs region selection by deducing the program structure around hot samples, performs transformations on the selected regions (e.g. optimization), and generates replacement code. The DBR agent then patches the client process to use the replacement code.

Abstract: A method, system and computer program product for testing software comprises discovering, by an agent executing on a computer, testable code configured to execute on the computer; receiving, by the agent, a request related to testing the testable code from a requestor; in response to the request, sending the requestor a property of the testable code; receiving, by the agent, data related to the property; activating; by the agent, the testable code wherein the received data is associated with the property in order to produce a result from the activated testable code; and returning, by the agent, the result to the requestor.

Abstract: A device receives code generated via a technical computing environment (TCE), performs a test on the code to generate a test result, and generates test information based on the performance of the test on the code. The device outputs or stores the test result, and receives, based on the test result, a request for a diagnostic analysis of the code. The device performs, based on the request, the test information, and at least one diagnostic, a diagnostic analysis of the code to generate a diagnostic result, and outputs or stores the diagnostic result.

Abstract: The illustrative embodiments provide dependency injection by static transformation. Information about a first software module among several software modules is identified. The first software module has a dependency on at least one other software module among the several software modules. Information about the dependency of the first software module on at least one other software module is identified. Using the information about the first software module and the information about the dependency, code is generated for the first software module to resolve the dependency.

Abstract: In an information processing apparatus, a program execution section executes a program, and in the stage of execution of a log acquisition command, acquires the value of a variable set in the log acquisition command. A trace log generation section generates a trace log including identification information on a file set in the log acquisition command, version number on a source code, and the acquired value of the variable, and stores the trace log in a storage device. A source code acquisition section acquires a source code corresponding to a combination of the identification information and the version number, based on the trace log. A character string addition section extracts a character string related to the value of the variable included in the trace code, from the acquired source code, adds the extracted character string to the trace log, and stores the trace log in a storage device.

Abstract: A programming language and computer system adapted to receive and execute f-programs written in a programming language that provides a mechanism to sequence and check the correctness of the execution of a plurality of code segments. The method provides for sequencing the execution of p-segments by a computer processor, where each p-segment is a sequence of one or more executable statements. The p-segments may be part of a manipulation program. An f-program includes a number of f-segments. The manipulation program is configured so that after the completion of execution of each p-segment, control is passed to a specific f-segment associated with the completed p-segment, and at least one variable identifier and value of the variable computed by the completed p-segment is passed to the f-segment so that the f-segment either causes execution to terminate or passes control to one of the p-segments.

Abstract: A method for processing test results from testing operation of software. A test result of pass, fail status, or unperformed is received for each test case of a test performed for each release of the software. A group to which each test belongs is ascertained. A test result stability index is calculated for each test case as being proportional to a total number of consecutive releases that include and are prior to the last release of the software such that the test result for each of the consecutive releases denotes a pass. A module stability index is calculated for each test case as being a summation over a product of a weight at each release and a binary stability indicator of 0 at each release for which the test result is changed from that of the immediately prior release and 1 at every other release.

Abstract: A process for detecting errors in computer code in C/C++ language in a computer, which comprises the operations of: —making available in said computer a source computer program (P) containing computer codes in C/C++ language; compiling (Z) said source computer program (P) to obtain an executable program (E); and —executing (240) said executable program (E) to generate (245) an error report (R). According to the invention, said method comprises, prior to the operation of compilation (Z): executing an operation of syntactic analysis (AS) to identify variables (x) having a structure of vector or pointer; modifying said source computer program (P) via the application to said identified variables (x) of a test function (f ( . . . ); io_sper; io_sper2; io_sper3; io_sper4) that is able to veriCy, during the operation of execution, whether an index (y) supplied for said variable x is valid.

Abstract: Some embodiments provide a system that generates a test suite for a software program. During operation, the system obtains a set of inputs for the software program and determines a coverage of the software program associated with the set of inputs. Next, the system determines a subset of the inputs which substantially provides the coverage of the software program. Finally, the system uses the subset of inputs as the test suite for the software program.

Abstract: Identifying conflicting declared invalid runtime references of overlaid data structures of a shared memory area as declared in a program listing. The identifying includes identifying a first data structure and a first parameter list in the program listing. A first routine call and a sequential flow of execution of the first routine call through the program listing in order to write data to the shared memory area are identified. A second data structure and a second parameter list in the program listing are identified. A second routine call and a second sequential flow of execution of the second routine call through the program listing in order to write data to the shared memory area are identified. It is determined whether the second routine call is attempting to overwrite data of the first routine call with the data of the second routine call in the shared memory area.

Abstract: A Unified Debugger that enables the debugging of graphical models with combinations of entities from multiple domains such as time-based block diagrams, statecharts, and physical system models, with additional features for the debugging of hand-written and automatically generated code is disclosed. A view of the entity being executed that is consistent with the type of the modeling domain to which the entity currently being executed belongs is automatically generated for a user. Rather than requiring a user to manually transition from one debugger to the next, the Unified Debugger applies the appropriate debugging features from each modeling domain. The Unified Debugger also enables integration of diagnostic information from a multitude of modeling domains into a central user interface. In addition, a standard diagnostic interface which spans a plurality of modeling domains is defined that enables the customization of debug behavior.

Abstract: A method of testing web services using a web service testing framework can include using a data parser to parse data for the web service to be tested. The data parser may be one of a plurality of data parsers in a test library for support of a plurality of data formats for the web service. If the web service is in a simple object access protocol (SOAP) protocol, the data can be converted into framework objects. These framework objects for the simple object access protocol (SOAP) protocol may then be converted into test objects. If the web service is in a representational state transfer (REST) protocol, the data itself can be converted into the test objects. A web service test can be accessed from the test library for testing the web service. The web service test can be executed using the test objects.

Abstract: A system and method for analyzing the real-time performance of a communication device. An aspect of the present invention records information input to the communication device during real-time operation of the communication device. A playback device or module may execute a model of the communication device in a non-real-time environment according to the recorded real-time input information. System execution in the non-real-time playback environment may, therefore, be equivalent to the original operation of the communication device that occurred in real-time. Accordingly, situations that occur in real-time may be efficiently recreated in non-real-time playback. An operator may analyze the past real-time performance of the communication device using the playback device or module, the recorded real-time input information, and a debugger utility if desired, without conducting additional trials to reproduce the desired operational situation.

Abstract: Methods and an apparatus for dynamic best fit compilation of mixed mode instructions are provided. In one embodiment, a provided method includes receiving a non-native software instruction at a device, generating a first native software instruction from a first instruction set based on the non-native software instruction, the generation of the first native software instruction occurring at the device, executing the first native software instruction at the device, generating a second native software instruction from a second instruction set based on the non-native software instruction, the generation of the second native software instruction occurring at the device, and executing the second native software instruction at the device.

Abstract: A method and system for testing a computer software system based on execution paths including: executing the computer program to obtain an execution path in the computer software; recording the execution path; modifying variables in the recorded execution path to create one or more perturbed paths; analyzing the one or more perturbed paths to detect potential errors; and generating unit tests for the one or more perturbed paths having the detected potential errors. The created test units may then be executed to test the computer software.

Abstract: A method for detecting defects in a computer program.

Abstract: A target program is instrumented during execution by using statements in high-level programming languages, without restarting the target and without modifying the compiled binary of the target on disk. The target and the analysis program modifying it may each include managed code. The target program is presented by an instrumentation API as a queryable database, rather than a mere sequence of processor-level instructions. An instrumentation context for the target program's execution image is obtained, with identifications of functions, individual instructions, and other instrumentable items that satisfy criteria specified in a query. Functions and low-level instructions may be identified as satisfying the query regardless of whether they have executed yet. High-level statements transform query-satisfying items in the target's execution image, by appending code, injecting a fault, replacing an individual instruction, or replacing an individual operand.

Abstract: Preparing a computer software application for static analysis by identifying a control flow within a model portion of a computer software application having a model-view-controller architecture, where the control flow passes a value to a controller portion of the computer software application, analyzing a declarative specification of the controller portion of the computer software application to identify a view to which the controller portion passes control based on the value, and synthesizing a method within the computer software application, where the method calls the view.

Abstract: A method includes accessing a validator routine having an input string and one or more return points, each return point returning a return value having two possible values; finding the return points in the validator routine; for each of the return points, performing a backwards traversal from a return point through a code section and determining constraints on the input string based at least on one or both of the two possible return values for the return point; using the determined constraints for the input string, determining whether all of the return values returned from the one or more return points meet validation constraints; and outputting one or more indications of whether all of the returned values returned from the return points meet the validation constraints for the one or both of the two possible return values. Apparatus and computer program products are also disclosed.

Abstract: A method is provided method to evaluate impact of a change in code of a depended upon component of a system stored in a non-transitory computer readable storage device, upon a dependent component of the system, the method comprising: identifying a dependency relationship between a first component stored in a storage device and a second component stored in the storage device; in response to a determination that the second component depends upon the first component, configuring a computer system to obtain a first property evaluation corresponding to the first component; and in response to obtaining the first property evaluation corresponding to the first component, configuring the computer system to associate the first property evaluation with the second component, and determine a second property evaluation corresponding to the second component, is the second component being associated with the first property evaluation.

Abstract: A hybrid program analysis method includes initiating a static program analysis of an application, generating, by a static program analyzer, a query to a dynamic program analyzer upon determining a code construct of the application requiring dynamic analysis, resolving, by the dynamic program analyzer, the query into a set of arguments with which to invoke the code construct of the application, generating, by the dynamic program analyzer, the set of arguments, invoking, by the dynamic program analyzer, the code construct of the application using set of arguments, answering, by the dynamic program analyzer, the query, and continuing the static program analysis of the application.

Abstract: Embodiments described herein relate to systems and methods for displaying aggregated stack traces in a source code viewer. One or more execution identifiers are received in response to an execution of a first program executing on one or more client computing devices. Each execution identifier can include one or more stack frames, which correspond to a function call within the first program. An error-likeliness score is identified for each execution identifier. An error-weight is determined for each of the execution identifiers based on the identified error-likeliness scores for instances of the execution identifiers.

Abstract: Described are various techniques by which a concurrent program is analyzed with respect to timing. In one aspect, code fragments in a concurrent program are modified and/or instrumented by inserting iteration counters inside loops. Examples of modified fragments include those corresponding to concurrently executing code fragments, non-blocking concurrent code fragments, blocking concurrent code fragments, fragments having a loop that may not terminate, fragments having interlocked operation, or fragments having a timeout. Such fragments are modified and/or flagged so as to provide the summary data. When statically analyzed, the instrumented code provides complexity information regarding each fragment, or combinations of fragments, such as concurrent fragments. Summary data regarding the concurrent program is provided by processing the complexity information into at least one computation graph.

Abstract: A virtual machine system decouples dynamic program analysis from program execution. Program analysis is decoupled from program execution through the use of a virtual machine to record program execution and an analysis platform to replay and analyze the program execution. Optimization techniques are applied to prevent the analysis platform from falling too far behind the program execution platform during replay.

Abstract: A program trace is obtained and events of the program trace are traversed. For each event identified in traversing the program trace, a trace slice of which the identified event is a part is identified based on the parameter instance of the identified event. For each trace slice of which the identified event is a part, the identified event is added to an end of a record of the trace slice. These parametric trace slices can be used in a variety of different manners, such as for monitoring, mining, and predicting.

Abstract: Test coverage is enhanced by measuring various types of coupling between coverage tasks. The coupling measurements may be implicit coupling measurements, explicit coupling measurements, coding coupling measurements, performance coupling measurements, resource coupling measurements or the like. Based on the coupling measurements, different coverage tasks may be grouped together. For example, closely coupled coverage tasks may be grouped together. The groups may also be determined based on an initial distribution of groups, by combining groups having closely coupled member coverage tasks. The groups may be ordered and prioritized, such as based on the size of the groups and the number of uncovered tasks in each group. The groups may also be ordered, such as based on coupling score which aggregate the coupling measurements of the member coverage tasks.