Abstract: To achieve end-to-end security, traditional machine-to-machine security measures are insufficient if the integrity of the graphical user interface (GUI) is compromised. GUI logic flaws are a category of software vulnerabilities that result from logic flaws in GUI implementation. The invention described here is a technology for uncovering these flaws using a systematic reasoning approach. Major steps in the technology include: (1) mapping a visual invariant to a program invariant; (2) formally modeling the program logic, the user actions and the execution context, and systematically exploring the possibilities of violations of the program invariant; (3) finding real spoofing attacks based on the exploration.

Abstract: A method and system are provided for automatically testing a program for automation systems (e.g., programmable logic controllers) with regard to maintaining programming guidelines for program design for automation systems. A copy of at least part of a safety-related program is obtained from a development system for automation systems as a copy to be tested. The program copy to be tested is loaded into a test device for testing programs. The test device has access to programming guidelines for program testing. The test device automatically performs the program test with regard to maintaining programming guidelines, and outputs the test result.

Abstract: Disclosed is a computer program product to track allocation of a plurality of objects in a heap. A data processing system, during an object allocation, prevents an object from being moved to another place in memory or being deleted. The data processing system prevents such activity concurrently with garbage collection on a second object not currently being allocated. The data processing system notifies a profiler of object information based on the object allocation via a callback function, wherein object information is a one-to-one mapping of the object address. The data processing system revives garbage collector processing of the object.

Abstract: Example systems and methods of providing an application programming interface tracing mechanism are presented. In one example, an application programming interface for an application is provided, the interface including an interface object. A proxy object is created for the interlace object. At the proxy object, method calls from the application for the interface object are received, recorded, and passed to the interface object. An execution trace including the recorded method calls is generated.

Abstract: A method and system for generating a set of service definitions relating to a computer application based on a set of interaction models relating to a set of participants in the interaction models. For each participant, a set of message traces is extracted from the set of interaction models and common message events in each message trace are identified. The common message events are transformed into service actions and a service definition is generated including the service actions. The generated service definition may then be deployed on a suitable computing system, such as, for example, a Service Oriented Architecture (SOA) platform.

Abstract: The present invention extends to methods, systems, and computer program products for identifying software execution behavior. Embodiments of the invention can be used to assist a user in a making a reasoned and informed decision about whether the behavior of executable code is malicious. Data indicative of executable code behavior can be collected statically without having to execute the executable code. Behavior data can be collected essentially automatically with little, if any, user involvement. A user initiates analysis of executable code and is provided a visual categorized representation of behavior data for the executable code.

Abstract: A mechanism is provided to automate the mapping so that custom widgets that cause compliance errors in the Web page can be identified automatically. The mechanism dynamically creates and inserts debug directives into the HTML code generated from a custom widget in a Web page so that a compliance error found in the generated code can be traced back to the custom widget that caused the error.

Abstract: A system and method for receiving an image of compiled user code, scanning the image to determine each of a plurality of functions included in the user code and creating a separately compiled executable module corresponding to selected ones of the plurality of functions, wherein the module includes instructions to create a stack trace for the selected ones of the functions.

Abstract: Embodiments of the present invention provide a system profiler that can be used on any processor architecture. In particular, instead of copying an entire stack every time, the stack is divided into blocks of a fixed size. For each block, a hash value is computed. As stack blocks are sent out of the kernel, the hash value and a copy of the block contents is kept in a user space cache. In the kernel, the hash codes of sent stack blocks are tracked in a table. During system profiling, the kernel module sampling the call stack determines if that stack block was previously sent by checking for the hash value in the kernel table. If the hash matches an entry in the kernel table, then only the hash value is sent. If the hash value is not in the table, the entire block and the hash value is sent.

Abstract: One embodiment of the present invention provides a system that inserts faults to test code paths. The system starts by placing fault-inserting method calls at join points within methods in program code. The system then executes the program code during a testing process. As a method is executed during the testing process, the system executes the corresponding fault-inserting method. This fault-inserting method checks a configuration database to determine whether a fault is to be simulated for the method and, if so, simulates a fault for the method.

Abstract: A processing circuit 4 is responsive to at least one conditional instruction to perform a conditional operation in dependence on a current value of a subset of at least one condition flag 22. A trace circuit 6 is provided for generating trace data elements indicative of operations performed by the processing circuit 4. When the processing circuit 4 processes at least one selected instruction, then the trace circuit 6 generates a trace data element including a traced condition value indicating at least the subset of condition flags 22 required to determine the outcome of the conditional instruction. A corresponding diagnostic apparatus 12 uses the traced condition value to determine a processing outcome of the at least one conditional instruction.

Abstract: A system and method thereof for performing loss-less migration of an application group. In an exemplary embodiment, the system may include a high-availability services module structured for execution in conjunction with an operating system, and one or more computer nodes of a distributed system upon which at least one independent application can be executed upon. The high-availability services module may be structured to be executable on the one or more computer nodes for loss-less migration of the one or more independent applications, and is operable to perform checkpointing of all state in a transport connection.

Abstract: A method for application performance data collection includes steps or acts of: customizing a performance tool for collecting application performance data of an application; modifying the application by inserting the performance tool while the application does not need to be rebuilt from the source; executing the application; and collecting the application execution performance data such that only interesting data is collected. Customizing the performance tool proceeds by implementing at least one configurable tracing function that can be programmed by the user; compiling the function(s) into an object file; and inserting the object file into the performance tool using binary instrumentation.

Abstract: A method is implemented in a computer infrastructure having computer executable code tangibly embodied on a computer readable storage medium having programming instructions. The programming instructions are operable to receive a tool error output determined by a code inspection tool and select at least one defect classification mapping profile based on the code inspection tool. Additionally, the programming instructions are operable to map the tool error output to one or more output classifications using the selected at least one defect classification mapping profile and generate at least one report based on the one or more output classifications.

Abstract: Embodiments of the invention generally relate to injection context based static analysis of computer software applications. Embodiments of the invention may include selecting a sink within a computer software application, tracing a character output stream leading to the sink within the computer software application, determining an injection context of the character output stream at the sink, where the injection context is predefined in association with a state of the character output stream at the sink, identifying any actions that have been predefined in association with the identified injection context, and providing a report of the actions.

Abstract: Implementations of the present disclosure provide methods including executing an application, generating a method parameter trace, the method parameter trace providing one or more parameter values corresponding to one or more methods called during execution of the application, generating an event trace, the event trace identifying one or more events occurring during execution of the application, and combining the method parameter trace and the event trace to provide a profile of events occurring during each of the one or more methods based on the one or more parameter values.

Abstract: A performance projection system includes a test IHS and multiple currently existing IHSs. The performance projection system includes user application software and surrogate programs that execute on currently existing IHSs. The performance projection system measures user application software and surrogate program performance during execution on currently existing IHSs. The performance projection systems measures runtime program performance during execution of surrogate programs on a future semiconductor die IC design model or virtualized future system. Designers normalize and compare surrogate program runtime performance data with user application software performance data. Designers un-normalize the normalized runtime performance data to generate a projection of runtime performance on the future system.

Abstract: Profiling operating context. At least some of the illustrative embodiments are a computer-readable medium storing a program that, when executed by a processor, causes the processor to obtain values indicative of a state of an operating context parameter during execution of a traced program on a target processor, and display an indication of a proportion of time during a trace period of the traced program that the target processor operated with the operating context parameter in a particular state.

Abstract: An analysis system may perform network analysis on data gathered from an executing application. The analysis system may identify relationships between code elements and use tracer data to quantify and classify various code elements. In some cases, the analysis system may operate with only data gathered while tracing an application, while other cases may combine static analysis data with tracing data. The network analysis may identify groups of related code elements through cluster analysis, as well as identify bottlenecks from one to many and many to one relationships. The analysis system may generate visualizations showing the interconnections or relationships within the executing code, along with highlighted elements that may be limiting performance.

Abstract: A system and method are provided to integrate profiling and debugging. In one embodiment, a profiling infrastructure is generated, the profiling infrastructure having profiling components capable of performing profiling sessions. An integrated infrastructure is generated by associating the profiling infrastructure with a debugging infrastructure, the debugging infrastructure having debugging components capable of performing debugging sessions. The profiling sessions and the debugging sessions are simultaneously performed via the integrated infrastructure.

Abstract: In one embodiment, a trace optimizing engine may create an optimized trace of an operation segment of a software program. A memory may store a trace of an operation segment and an inherited stack frame from the operation segment. An optimizing trace compiler may resolve a local pointer of the operation segment to a memory object and insert a guard in the trace that invalidates the trace if the local pointer does not resolve to the memory object. A just in time compiler may receive in the trace a stack pointer to the inherited stack frame, move the stack pointer to create a storage space, and store an intermediate value for a local variable in a temporary variable in the storage space.

Abstract: A computer-readable medium and method may include instructions for providing a graphical model in a computing environment, where the graphical model includes a plurality of graphical affordances. Generated code may be provided based on the graphical model, where the generated code includes a plurality of code segments. A traceability report may be generated based on the graphical model and the generated code, wherein the traceability report includes a mapping of the plurality of code segments to corresponding ones of the plurality of graphical affordances. The traceability report may be stored.

Abstract: Methods and systems are disclosed for analyzing performance of a translated code stream executing within a central processing module. One method includes, during execution of one or more native instructions corresponding to each non-native operator in the code stream by the code execution unit, counting the occurrence of the non-native operator, determining a duration of execution of the one or more native instructions, and adding the non-native operator to a trace sequence. The method also includes, after execution of the code stream within the central processing module, generating a data file of non-native operators executed within the code stream, the data file of operators including a name of each non-native operator, an elapsed amount of time within the code execution unit that the one or more native operators corresponding to the non-native operator are executed, and a number of occurrences of the non-native operator within the code stream.

Abstract: An analysis system may perform network analysis on data gathered from an executing application. The analysis system may identify relationships between code elements and use tracer data to quantify and classify various code elements. In some cases, the analysis system may operate with only data gathered while tracing an application, while other cases may combine static analysis data with tracing data. The network analysis may identify groups of related code elements through cluster analysis, as well as identify bottlenecks from one to many and many to one relationships. The analysis system may generate visualizations showing the interconnections or relationships within the executing code, along with highlighted elements that may be limiting performance.

Abstract: Method, system, and computer program product embodiments of a time-based trace facility for facilitating software debugging without interfering with the run-time behavior, performance or resource usage of the traced software are provided. The trace facility resides in a different address space than the target address space and uses different time-slices of CPU resources to execute the instructions in the address spaces. The trace facility uses a cross-memory mode to read the state data from the target address space in accordance with a time schedule. The trace facility writes the state data to a trace area, which may be located in either the target or trace address spaces or external storage. With this approach, the trace facility can read a large amount of state data frequently to construct the type of historical record needed to analysis run-time behavior, performance and resource usage.

Abstract: A method, system, and computer program product for identifying invalid memory references. In one embodiment, invalid memory references are identified as they occur. In another embodiment, the invalid memory references are identified within a customized operating system that runs within an application.

Abstract: Methods, apparatus, and computer program products are disclosed for debugging a high performance computing program by gathering lists of addresses of calling instructions for a plurality of threads of execution of the program, assigning the threads to groups in dependence upon the addresses, and displaying the groups to identify defective threads.

Abstract: A solution is proposed for metering the usage of Java programs. For this purpose, each Java program to be metered is associated with a fingerprint defined by a reference sequence of classes that must be loaded for its execution. The sequence of classes that are actually loaded by the Java Virtual Machine (JVM) is monitored, for example, by means of a wrapper for a class loader of the JVM. The sequence of loaded classes is then used to identify the Java program in execution (which fingerprint matches this sequence of loaded classes).

Abstract: This disclosure provides various implementations for supporting multiple system and application tracing. In one aspect, software can generate a globally unique identifier (GUID) for a first business process associated with a trace and transmit the GUID to a remote computer for association with a second business process related to the first business process. In another aspect, the software can identify a GUID for a trace that is executing for a first business process that is associated with a first application. The software can then associate the GUID with a second trace for a second business process related to the first business process, where the second business process is associated with a second heterogeneous application disparate from the first application. In some instances, the GUID may comprise a combination of a system identifier, a business process identifier, and a time identifier.

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: A method and an apparatus that generate tracer data randomly and infrequently for origins and destinations of values created during runtime of a compiled code of a source code is described. A tracer graph may be updated to record the origins and destinations of the values during the runtime. The compiled code may be optimized to reduce processing resources between the origins and the destinations of the values according to the tracer graph. The optimized compiled code may be executed for at least a portion of the source code.

Abstract: Embodiments of the invention provide systems and methods for analyzing memory heap information for investigation into a memory leak caused by an application. According to one embodiment, a method of analyzing heap data can comprise obtaining the heap data from a memory. The heap data can represent a plurality of objects of one or more classes, each object identifying a referrer instance, a field in the referrer, and a referent instance. A statistical analysis can be performed on the heap data to identify objects within the heap that are contributing to a growth of the heap. The heap can be traversed based on the referrer instance of one or more objects identified as contributing to the growth of the heap to a root object identified as not contributing to the growth of the heap.

Abstract: A software system is disclosed that provides remote troubleshooting and tracing of the execution of computer programs. The software system includes an information-gathering module that gathers run-time information about program execution, program interaction with the operating system and the system resources, monitors user actions and captures screen output, and passes the gathered information to an information-display module, the gathered information allowing a support technician (e.g., a software developer, a help desk person, etc.) to see the user interactions with the program and corresponding reactions of the system, and/or to remotely view environment variables, file access operations, system interactions, and user interactions that occur on the user's computer and locate failed operations that cause execution problems.

Abstract: In some embodiments a method includes storing a micro-code patch stub in a micro-code patch memory, storing a micro-code patch corresponding to the micro-code patch stub in a system memory, in response to an event and in response to the stored micro-code patch stub, loading the stored micro-code patch from the system memory to the micro-code patch memory, and processing the micro-code patch from the micro-code patch memory. Other embodiments are described and claimed.

Abstract: Given a program P, a specification S, and an abstraction function ?, verification determines whether P satisfies the specification S under the abstraction ?. If not, a trace T that violate the specification is selected, and either the abstraction ? is refined or a constraint that avoids the trace T is computed and added to a set of constraints. The set of constraints are used to modify the program P.

Abstract: A debugger includes a thread holding mechanism that analyzes the code being executed by multiple threads, and delays holding each thread that is currently executing system code external to the program until the thread is no longer executing the system code external to the program, or until some threshold is exceeded. Delaying holding of a thread that is executing system code external to the program avoids potential conditions that could lock up the debugger.

Abstract: A method, apparatus, and a computer program product are disclosed for selectively activating a trace function in a computer program in response to a call of a predetermined trigger code element so that trace data is produced only for those subroutines that call the trigger code element or are called by the trigger code element. The computer program product provides one or more trace code elements for one or more selected subroutines of the computer program stored on internal memory of a digital computer. The trace code elements provide trace data for said selected subroutines. The computer program product also selects a subroutine as a trigger code element, processes the computer program, monitors the call stack for the trigger code element, and enables the trace code elements for each selected subroutine simultaneously present in the call stack if the trigger code element is identified in the call stack.

Abstract: A plurality of user interactions in a baseline computing system are intercepted and recorded, in an artifact file, with a benchmarking tool. The recorded user interactions from the artifact file are replayed and injected to a software stack of a system under test (whose performance is to be compared to the baseline system), using the benchmarking tool. During the replay, screen updates in the system under test are sequentially compared with expected screen images from the artifact file, until a match is observed in a given case. A response time associated with each of the matches is recorded.

Abstract: A software tool allows a user to filter out the results produced by a software source code correlation program that is executed on sets of software source code files. The tool allows the user to discard elements of source code that are not relevant to the analysis without requiring the user to run the correlation program multiple times.

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: During runtime of a binary program file, streams of instructions are executed and memory references, generated by instrumentation applied to given ones of the instructions that refer to memory locations, are collected. A transformation is performed, based on the executed streams of instructions and the collected memory references, to obtain a table. The table lists memory events of interest for active data structures for each function in the program file. The transformation is performed to translate memory addresses for given ones of the instructions and given ones of the data structures into locations and variable names in a source file corresponding to the binary file. At least the memory events of interest are displayed, and the display is organized so as to correlate the memory events of interest with corresponding ones of the data structures.

Abstract: A method for validating a translation of a graphical workflow of activities into an arbitrary, but structured language uses as input a term of a high level graphically expressed language having a number of graphical elements related logically to each other and analyzes its content and/or structure in order to translate this content and/or structure into a structured set of instructions. The graphical workflow of activities is simulated to arrive at a first set of activity results. Each instruction is translated into a generic language in order to trace the execution of such instruction to arrive at a second set of results from the translated instructions. The first set of activity results is compared with the second set of results, and the translation is validated in case of a match among the first set of activity results and the second set of results.

Abstract: A method for automatic identification of execution phases in load test data includes receiving load test data indicating processor utilization for threads over a period of time divided into a plurality of intervals. For each pair of proximate intervals, it is determined whether thread-wise processor utilization for a first interval is statistically indistinguishable from that of a second interval. The pair of proximate intervals is combined when it is determined that the processor utilization for the first interval is statistically indistinguishable from that of the second interval. Each of the pair of proximate intervals is divided into subintervals when it is determined that the first interval is not statistically indistinguishable the second interval. One or more execution phases are automatically identified as occurring between proximate intervals that are not substantially equivalent.

Abstract: System and method for analyzing a graphical program. A graphical program is provided that includes a plurality of interconnected nodes that visually indicate functionality of the program. The graphical program includes a plurality of block diagrams arranged in a hierarchical manner, including a top-level block diagram and one or more sub-block diagrams, where each block diagram includes a respective subset of the plurality of interconnected nodes. At least one of the block diagrams includes a node that includes at least one of the sub-block diagrams. When a block diagram executes, all the respective nodes of the block diagram execute. Each node in the plurality of interconnected nodes is configured to provide graphical code coverage information when executed. The graphical program is executed, thereby generating graphical code coverage information for the graphical program indicating which nodes executed, which is then stored.

Abstract: Methods, apparatus, and computer program products are disclosed for debugging a high performance computing program by gathering lists of addresses of calling instructions for a plurality of threads of execution of the program, assigning the threads to groups in dependence upon the addresses, and displaying the groups to identify defective threads.

Abstract: Executing a simulation of a computer platform, the simulation including simulation models. A dynamic quantum is accessed whose current value specifies a maximum number of units of execution a simulation model is allowed to perform without synchronizing with another simulation model. The dynamic quantum may be received from a user. Respective simulation models are invoked for execution with the current value of the dynamic quantum provided to each of the simulation models. The method also comprises modifying the value of the dynamic quantum based on a simulation event.

Abstract: A method, apparatus and computer program product are provided for implementing performance impact reduction of watched variables. Source code is parsed and a variable in the source code to be watched is identified. The identified variable is allocated to a predefined page of storage. The predefined page of storage is separated from frequently accessed variables, such as, a page containing least frequently modified variables, a last page associated with a static storage, and a separate page added for receiving the identified variables to be watched.

Abstract: A method and system for data centric heap profiling is disclosed. In one embodiment, a method, implemented in a computing device, for data centric heap profiling includes generating a type table for data structure types in source code using a compiler of the computing device. The method also includes identifying each heap allocation site and a corresponding data structure type in the source code using the compiler. The method further includes generating a data centric view of a heap o fan application compiled from the source code based on the each heap allocation site and the corresponding data structure type using a debugger of the computing device when a snapshot of the heap is requested during an execution of the application.

Abstract: Techniques for the design and use of a digital signal processor, including (but not limited to) for processing transmissions in a communications (e.g., CDMA) system. Inter-thread trace alignment with execution trace processing includes recording timing data relating to a common predetermined event. Such an event may be the number of cycles since a last thread initiated execution tracing or the number of cycles since all threads terminated execution tracing. The number of cycles at which a thread initiates execution tracing is referenced to the common predetermined event for maintaining the timing of execution tracing. The data relating to the common predetermined event is then updated to associate with the time at which the thread initiated execution tracing. The result is to permit aligning the timing data associated with all threads.

Abstract: Electronic test system including hardware and software components and method of use which provide obsolescence mitigation. A test program set (TPS) including a test program test is created to enable units to be tested. When a new component is introduced, the change is detected and a new TPS is created with at least part of the test program test. If the new TPS complies with defined, governing rules for the system, testing using the new TPS is possible. If not, a determination is made as to whether any component of the TPS is obsolete and if not, the units can be tested using the new TPS without redefining the rules. When a component of the TPS is obsolete, the rules are reviewed to ascertain the effect of removal of the component and optionally redefined to enable the new component to be used in combination with the remaining components.