Abstract: A system and method for profiling a software application may include means for capturing profiling information corresponding to an instruction identified as having executed coincident with the occurrence of a runtime event, and for associating the profiling information with the event in an event set. In some embodiments, the identified instruction, which may have triggered the event, may be located in the program code sequence at a predetermined position relative to the current program counter value at the time the event was detected. The predetermined relative position may be fixed dependent on the processor architecture and may also be dependent on the event type. The predetermined relative position may be zero, indicating that when the event was detected, the program counter value corresponded to an instruction associated with the event. If the identified instruction is an ambiguity-creating instruction, an indication of ambiguity may be associated with the event.

Abstract: Systems and methods are provided for instrumenting compiled software to include diagnostic information such that an origin of a call to one or more routines may be more easily identified. For example, a system is provided which unassembles or uncompiles software into a more readily identifiable instructional form, which is then searched to identify various calls to various routines of interest. Portions of the identified calls are then modified with diagnostic information that will identify the call. This diagnostic information and the call are then recorded so that the call may be subsequently traced back to its origin when, for example, an error occurs.

Abstract: A method for optimizing a code section prior to performing register allocation for variables referenced in the plurality of computer instructions. The method includes performing at least one of a full prematerialization or a partial prematerialization for a variable in the plurality of computer instructions. The full prematerialization replaces the variable in every use of the variable in the plurality of computer instructions with one or more variants of the variable and replaces a definition of the variable with a nop instruction. The partial prematerialization replaces some but not all occurrences of the variable in uses of the variable in the plurality of computer instructions with one or more variants of the variable without replacing the definition of the variable with the nop instruction.

Abstract: A method for installation and configuration of a software product includes installing a software product and determining configuration settings of the software product based upon a social network of peers. A system for installation and configuration of at least one software product includes at least one client install package capable of utilizing a social network for at least one of installing software; transmitting configuration settings; transmitting post-installation configuration settings; or responding to post-installation configuration modifications; and a server that stores and aggregates the configuration settings of a plurality of users, forming at least one social network.

Abstract: A method and apparatus for automatic second-order predictive commoning is provided by the present invention. During an analysis phase, the intermediate representation of a program code is analyzed to identify opportunities for second-order predictive commoning optimization. The analyzed information is used by the present invention for apply transformations to the program code, such that the number of memory access and the number of computations are reduced for loop iterations and performance of program code is improved.

Abstract: A procedure is provided to implement modifications to a running object-oriented program, in particular a program for controlling an automation facility. The program is stored temporarily in a memory in the form of an intermediate code which can be converted into executable machine code in runtime. The method includes the steps of providing a modified program or a modified program module, also in the form of an intermediate code, and comparing the intermediate code of the modified program or that of the modified program module with the intermediate code of the running program for determining the modifications, and implementing modifications to the running program. A correspondingly adapted run-time system is also provided, which is suitable for implementing the procedure as well as the integration of this run-time system into an automation facility.

Abstract: Correlating profile data facilitates sophisticated code optimization. Going beyond one to one relationships between code execution hindrances and single code behavior attributes provides insight into code behavior at a finer level of granularity. The capability to aggregate profile data based on multiple code behavior attributes and filter based on instances thereof, allows code optimization decisions to be made based on presentation of profile data from various perspectives. Profile data, which includes code behavior attributes correlated with code execution hindrances, is aggregated based at least in part on a first code behavior attribute. Code behavior attributes include one or more of memory references, memory reference objects, functions, time ranges, processors, processes, threads, and source-level data objects. The aggregated profile data is filtered based on an instance of the first code behavior attribute.

Abstract: Building a package for installing a software application on a data processing system with a distributed architecture is provided. The installation package is built using an authoring tool based on a declarative model. A descriptor is used to define a desired configuration of the system. The installation package is built declaring a discoverer element, a producer element and a consumer element into the wizard tree. During the installation process, the discoverer element detects a current configuration of the system. The producer creates a working queue dynamically, inserting the installation operations that are needed for reaching the desired configuration from the current configuration of the system. The producer then executes the installation operations defined in the working queue. In this way, the installation operations are determined at runtime.

Abstract: Disclosed herein is an electronic device network for lifecycle management of firmware and software in electronic devices. The electronic device network may also be adapted to manage configuration parameters in the electronic devices. Lifecycle management provided by the electronic device network may include firmware and software downloading, firmware and software updating, and remote locking and remote enabling of electronic device capability. An update store module in the electronic device network may be adapted to dispense update packages to requesting electronic devices. The electronic devices may employ one or a plurality of update agents to update software and firmware therein.

Abstract: A method of analyzing simulation results of a model, the method comprising: obtaining a process model including model elements including tasks, non-reusable sub-processes, and called reusable sub-processes; assigning a unique identifier to each model-element; generating unique model-element-proxies for all model-elements except for model elements corresponding to a model-reusable-sub-process or a model element contained by a model-reusable-sub-process; generating unique model-element-proxies for model-reusable-sub-processes and model-elements contained by model-reusable-sub-processes; associating each generated model-element-proxy with a corresponding model-element; executing simulation of the process model and persisting for each element instance data produced during simulation, the instance data including an element instance identifier and a corresponding model-element-proxy identifier; querying persisted simulation data for information using model-element-proxy identifiers.

Abstract: A network-accessible Web service is generated without a user having to code the logic of the Web service using a programming language. The Web service is represented as a sheet element within a graphical user interface (GUI) displayed on the screen of a computing device. A number of cards for the Web service are defined. The cards define the logic of the Web service, and effectuate the functionality of the Web service. Each card is represented as a card element on the sheet element within the GUI. By manipulating and modifying the cards, a user is thus able to generate a Web service without having to code the logic of the Web service with a programming language.

Abstract: Embodiments of the present invention include code generation methods. In one embodiment, a table of patterns is generated. Each pattern in the table includes an FMA (fused multiply-add) DAG (Directed Acyclic Graph), a canonical form equivalent of the FMA DAG, and a shape corresponding to the canonical form equivalent. Incoming floating-point expressions are matched against the patterns in the table during compilation of a program to obtain optical sequences of FMA, FMS (fused multiply-subtract), and FNMA (fused negate multiply-add) instructions as compiled instructions for computing the floating point expressions.

Abstract: Techniques and tools are described for flattening nested streams. For example, a stream flattening tool processes nested streams on a stack to traverse the nested streams. The tool produces a flattened stream that enumerates the elements of the nested streams. In one embodiment, the tool initially pushes a stack frame onto the stack for a stream representing all of the nested streams. As the tool iterates across the “active” stream having the frame on the top of the stack, the tool may encounter and produce elements in the “active” stream. Or, the tool may encounter a nested stream and push a stack frame for the nested stream onto the stack, then continuing by iterating across the new active stream. The tool pops the stack frame for the active stream from the stack when the end of the stream is reached, or potentially earlier if handling a nested tail stream.

Abstract: An intelligent tool for assisting a developer during the creation or maintenance of software generates an icon when triggered by input. Upon selection of the icon, options are displayed for potential selection. Upon selection of an entry, event associated with the entry are deployed.

Abstract: Visualization for active execution tracing pertains to one or more tools used to capture and analyze events leading to a point-of-failure during execution of a function or at least a portion of an application, program, process, or other assemblage of programmable and executable code.

Abstract: The present invention provides methods of visualizing and modeling the interaction relationship among entities. An example method of visualizing the interaction relationship among entities includes the steps of: presenting the internal logic of entity in an entity container; and presenting the interaction relationship among the entities in an interaction space. A method of modeling the interaction relationship among entities, includes the steps of: defining each entity related to said interaction relationship; defining an interface of said each entity in an interaction space; and defining interaction logics among said interfaces in the interaction space.

Abstract: A system, method, and computer-accessible medium for logging and replaying asynchronous events are disclosed. One or more asynchronous events occurring during execution of a first instance of a computer program are logged. In logging the asynchronous events, a respective location in the execution of the first instance at which each of the one or more asynchronous events occurs is determined. A respective synchronous event preceding each asynchronous event is also determined. The asynchronous events are replayed during execution of a second instance of the computer program. In replaying each asynchronous event, the second instance is instrumented at the respective location during the execution of the second instance after detecting the preceding synchronous event.

Abstract: This invention describes a compilation method of extracting and implementing an accelerator control program from an application source code in a processor based system. The application source code comprises arrays and loops. The input application source code is sequential, with loop, branch and call control structures, while the generated output of this invention has parallel execution semantics. The compilation method comprises the step of performing loop nest analysis, transformations and backend processes. The step of loop nest analysis consists of dependence analysis and pointer analysis. Dependence analysis determines the conflicts between the various references to arrays in the loop, and pointer analysis determines if two pointer references in a loop are in conflict. Transformations convert the loops from their original sequential execution semantics to parallel execution semantics. The back-end process determines the parameters and memory map of the accelerator and the hardware dependent software.

Abstract: Migration of a user state from a source computing device to a destination computing device using a state migration point (SMP) is disclosed. The destination computing device may be the same as the source computing device but with a different operating system. The user state is securely stored by the SMP until the user state is restored on the destination computing device or a predetermined period of time has elapsed. Additional SMPs can be added without an architectural change. SMPs can be used to simultaneously migrate the states of multiple users of the source computing device to multiple destination computing devices. The SMPs can be restricted to migrate only the user states of computing devices with particular IP subnets. The SMPs can retain user states for a period of time after restoration in order to provide a backup, if necessary.

Abstract: Identification of software program data and configuration data. A set of installation data is identified from an installation log. A set of deduced data is determined based on the identified set of installation data, using various algorithms and heuristics. A set of program data is organized as a function of the starting and deduced data, said program data constituting all data belonging to the software. The software is applied from the source computing device to a destination computing device as a function of the organized set of program data such that the application process mimics the actions of the software's installer so that the software functions seamlessly on the destination computing device.