International Business Machines Corporation

Steven Cooper

Trong Truong

Michael S Fulton

Roger Harry Pett

Tom C Chen

Alan S Boxall

Reid T Copeland

Allan Henry Kielstra

Peter Andrew Nicholls

Toshihiko Koju

Roger H E Pett

Jeremiah S Swan

Tom C L Chen

Tao Guan

A method and system for synchronizing components of heterogeneous systems. A request is made to a host computer for a latest version of a client component pertaining to client code identified in a previously received communication. An object representing a latest version of a client component pertaining to client code is retrieved from one or more loadable modules at a host computer. The host computer includes a host component. The host component is host software configured to be executed in the host computer. A host component binary is built with a set of additional components bound to the host component binary. An encoding generated during compilation of the additional components transforms the client component into the object with an array populated with data of the client component. The object is built during link time into the one or loadable modules tightly bound with the host component binary.

Synchronization of components in heterogeneous systems

A method and system for synchronizing components of heterogeneous systems. A request is made to a host computer for a latest version of a client component pertaining to client code identified in a previously received communication. One or more loadable modules, which include an object representing the client component and are bound with a host component, are located at the host computer. The object is retrieved from the one or more loadable modules and sent to the client computer. A host component binary is built with a set of additional components bound to the host component binary. An encoding generated during compilation of the additional components transforms the client component into the object with an array populated with data of the client component. The object is built during link time into the one or loadable modules tightly bound with the host component binary.

A process for automatic version synchronization of dependent components running on heterogeneous systems. In response to receiving a communication using a predetermined protocol through a network at a host, it is determined whether required client code is not present on the client. In response to a determination required client code is not present on the client, a required version of the client component is requested at the host. One or more loadable modules are located at the host bound with a host component that represents the client component. An object comprising the one or more loadable modules is sent to the client, wherein the client receives, loads and runs the object as a new component to communicate with the host component at a latest level.

Embodiments of the present invention provide methods, computer program products, and systems to increase code coverage. Embodiments of the present invention can receive a copy of source code and data associated with a sample execution of a set of instructions specified by the copy of the source code. Embodiments of the present invention can insert, into the set of instructions specified by the copy of the source code, an instruction that corresponds to a code statement that precedes an untraversed code path within the received copy of the source code. Embodiments of the present invention can execute the set of instructions that include the inserted instruction and provide an option to redirect execution of the set of instructions at the inserted instruction. Embodiments of the present invention can generate a test case that increases code coverage based on the redirected execution of the set of instructions.

Test case generation for uncovered code paths

An approach for collection and presentation of runtime data semantics. At least one of code-coverage history, system runtime history and code version information are received. An inspection line of code or variable(s) are received and runtime data semantics is retrieved from at least one of code-coverage history, system runtime history and code version information. The runtime data semantics are filtered based on the inspection line of code and/or variable(s) and are output.

Automatic collection and presentation of runtime data semantics

Without using a high-level programming language source code, a set of sync points is identified in an initial binary code. The initial binary code is executed at a first system. A value of the user data is captured from a user space of a memory as a baseline of the user data. A set of comparative sync points is identified in a second binary code. During an execution of the second binary code, a second value of the user data from a second user space of a second memory is found to fail in matching the baseline of the user data. An instruction before the comparative sync point in the second binary code is identified as a location of a faulty operation due to the failing.

Performance neutral isolation of runtime discrepancies in binary code

For optimizing executable code, during a first compilation of a source code, a set of signatures is inserted in a first executable code. A signature in the set of signatures includes a combination of executable instructions. During an execution of the first executable in a debugger an instruction to call a counter code is executed from a location of the signature to increment a counter corresponding to the signature. A value of the counter is provided to a compiler to correspond with the location of the signature in the first executable code. The source code is recompiled into a second executable code, optimizing a portion of the second executable code responsive to the value exceeding a threshold. The portion is related to the location of the signature in the first executable code.

Feedback directed optimized compiling of optimized executable code

For debugging an application in a production environment, a breakpoint is set in the application. Responsive to the setting, recording is begun of information about a processing of a request in the application. Reaching the breakpoint is detected in the application during the processing of the request. A replica of the application is created including the breakpoint, the application becoming a primary application and the replica becoming a secondary application in a production environment. In the secondary application, a debugging operation is performed during a processing of a copy of the request after the breakpoint in the secondary application.

Minimally disruptive debugging in a production environment

An illustrative embodiment of a computer-implemented process for scalable group synthesis receives a group definition, applies a sub-set of conditions to the group definition to form a conditioned group definition, receives a set of entities and populates group membership using the received set of entities and the conditioned group definition, wherein each member responds in the affirmative to the sub-set of conditions.

Growing community of inventors

CA

Steven Cooper