Abstract: A method, apparatus, and computer instructions for referencing a constant pool. A determination is made as to whether a bytecode references the constant pool. A relative offset to the constant pool is identified for the bytecode, in response to the bytecode referencing the constant pool. The bytecode is then replaced with a new bytecode containing the relative offset. The relative offset is used to reference the constant pool.

Abstract: A method for comparing objects includes selecting a first object and a second object, each object associated with an instance of at least one primary parameter and an instance of at least one secondary parameter, each secondary parameter associated with one of the primary parameters. At least a portion of the first object and at least a portion of the second object are compared to identify one or more differences between the selected objects. At least a portion of the differences are identified as ignorable based, at least in part, on the one or more primary parameters.

Abstract: A method instruments a function in an executable file so that the instrumented function calls a generic preprocessor prior to execution of the body of the function. After the preprocessor modifies the original function's incoming parameters, the body of the function itself is executed. Finally, execution is directed to a generic postprocessor prior to returning from the function. The postprocessor modifies the outgoing parameters and return value. In one implementation, the parameters of an instrumented function are described and packaged into a descriptor data structure. The descriptor data structure is passed to the generic preprocessor and postprocessor. A generic processor uses the descriptor to select changed behaviors based on the calling context.

Abstract: A Modeling and Analysis Program (MAP) having a modeler, an estimator, and an evaluator is disclosed. The MAP guides the user through the design process. The modeler takes the user's input of a process diagram and creates a model organized by pages. An estimator is applied to the model to calculate the performance along the pages on each path in the model. The performance is compared to criteria. If the performance is not within a range acceptable to the user, then an evaluator is invoked. The evaluator makes recommendations for modifications to the model to improve performance.

Abstract: Techniques for debugging a computer program that includes multiple modules executing on multiple machines include receiving, at a unifying component, first data from a first machine. The first data indicates debugging information generated by the first machine. Second data is also received at the unifying component from a second machine. The second data indicates debugging information generated by the second machine. Based on the first data and the second data, third data is formed indicating a single integrated representation of debugging information for the computer program. The unifying component allows debugging information from several machines to be integrated and then presented to a user through a single debugger client.

Abstract: A workflow model is described. The workflow model includes a workflow that includes actual tasks, and a workflow view, or virtual workflow, that includes virtual tasks. Each of the virtual tasks is associated with at least one of the actual tasks. The workflow and virtual workflow are compiled into an aggregate workflow. By implementing the aggregate workflow in a workflow engine, the workflow and virtual workflow are executed concurrently and in synchronization with one another.

Abstract: This invention is directed to a method and apparatus for implementing native code directly in C++ with object structure very closely resembling the object structure of JAVA. The method provides for the mapping of JAVA to C++ objects and invoking the JAVA Native Interface, mapping C++ objects to JAVA and returning a corresponding JAVA object, retrieving and returning a class factory by class name, and collecting garbage in both the C++ and JAVA environments.

Abstract: A portable communication device is provided that receives upgrade files via a wireless coupling. The contents of the upgrade file include information to repair errors in software components of the portable communication device and/or information to upgrade functions of the portable communication device. An upgrade client of the portable communication device automatically upgrades the software components using the upgrade file contents. Automatic upgrades of the software components include self-upgrades to software components of the upgrade client.

Abstract: An exchange infrastructure for message-based exchange and integration of a collection of heterogeneous software components is disclosed. The exchange infrastructure includes a repository for storing design-time collaboration descriptions of a plurality of software components, and a directory for storing configuration-specific collaboration descriptions of a runtime system landscape. The exchange infrastructure further includes a runtime engine configured for message-based exchange of information based on the configuration-specific collaboration descriptions. At runtime, the runtime engine receives messages, and resolves intended or required receivers based on message content and parameters provided by the configuration-specific collaboration descriptions from the directory.

Abstract: Efficient and flexible support for parametric polymorphism in a dynamic execution environment is provided. The addition of efficient parametric polymorphism in a dynamic execution environment expands the support of features of various source languages in intermediate language code. Dynamic allocation of typing context data and support tables at runtime optimizes memory requirements and performance in a dynamic execution environment. As typing-context-relevant-code-points are executed within the program, indices are assigned to these code points and indexed slots in appropriate typing context data structures are allocated. As a typing-context-relevant-code-point is executed within a typing context, the indexed slot within the associated typing context data structure is filled in with typing context data. Such populated slots may be reused in subsequent execution of the code point within the same typing context to avoid re-computing the typing context data.

Abstract: An automated heterogeneous configurator employs a technique by which the state of a context can be changed and restored automatically to facilitate the configuration of systems having components that span multiple contexts. The technique employs a high level constraint that is programmed into the component class of a model that requires a component object to determine the appropriate context for that object at the beginning of its installation within the configuration, and if the current state of the context is not that which is appropriate for the object component, the installation process for the component changes the state of the context to reflect that which is appropriate for the component. The most common context is the product line context, but any other context pertinent to the configuration of heterogeneous systems can be applied to this technique.

Abstract: A software-to-hardware compiler is provided that generates hardware constructs in programmable logic resources. The programmable logic resources may be optimized in terms of being configured to make additional copies of regions on memory devices other than on the programmable logic resources (e.g., RAM). This facilitates multiple reads during a single clock cycle. Symbol set analysis is used to minimize the size of regions to allow for more efficient use of hardware resources.

Abstract: A method and system for creating reusable software components that can be automatically discovered and assembled on a network through the use of syntactic appearances in component languages. Component languages guarantee that any search for the syntactic features of a component, coupled with inheritance information, will locate the component with the correct semantic properties. In this way, the invention allows components to be automatically discovered without human intervention and increases the reusability of software as a whole.

Abstract: A XLANG/s compiler recognizes a statement in XLANG/s code to make an assumption as to the success or failure of a specified transaction. The assignment states of variables are tracked and changes to such states are recorded. While processing XLANG/s code, the compiler determines whether the assignment state of a particular correlation, operation or the like is correct for the transaction being performed. If not, the compiler may generate an error message. Moreover, by using declarative assumptions such as if(succeeded(T)) or if(!succeeded(T)), definite-assignment analysis of shared state variables may cross transactional boundaries.

Abstract: Code for a program is received by a compiler (or other entity). The code includes an expression for a variable and a marker that specifies when the expressions should be evaluated during execution of the program. Example markers can indicate that an expression should be evaluated immediately, once or always. Additional functionality is provided to the code in order to evaluate the expression at the specified time during execution of the program. If the expression is to be evaluated always, then the expression will likely be dependent on a item that can change. Functionality is provided that evaluates the expression when the item changes so that the variable can be updated.

Abstract: Methods of updating an electronic device having an update agent employing preprocessing techniques is disclosed. The methods described permit an electronic device having a non-volatile memory to update a plurality banks in an efficient manner, by preprocessing the original contents of the non-volatile memory. The preprocessing may comprise shifting one or more banks before performing an update, so as to create a moving, unoccupied bank or “bubble” into which the updated version of a bank may be stored. An embodiment of the present invention provides a reduction in the processing of the original memory contents, and extends the life of the non-volatile memory devices used.

Abstract: An embodiment of the present invention provides an optimizer for optimizing source code to generate optimized source code having instructions for instructing a central processing unit (CPU) to iteratively compute values for a primary recurrence element. A computer programmed loop for computing the primary recurrence element and subsequent recurrence elements is an example of a case involving iteratively computing the primary recurrence element. The CPU is operatively coupled to fast operating memory (FOM) and operatively coupled to slow operating memory (SOM). SOM stores the generated optimized source code. The optimized source code includes instructions for instructing said CPU to store a computed value of the primary recurrence element in a storage location of FOM. The instructions also includes instructions to consign the computed value of the primary recurrence element from the storage location to another storage location of the FOM.

Abstract: System and method for deploying or executing a graphical program to a device in a wireless manner. A graphical program (GP) is created that implements a measurement function. Some or all of the GP is transmitted to a hub over a network. The hub executes the transmitted GP and sends corresponding commands to a measurement device via wireless means in accordance with a wireless communication protocol. The measurement device executes the commands to perform the measurement function, thereby generating resultant data, which is received from the measurement device via wireless means. The GP may include a block diagram that executes on the measurement device, and a user interface portion that is displayed by a first computer system. Transmitting the GP to the hub may include generating a machine-executable program based on the GP and transmitting the machine-executable program to the hub for execution.

Abstract: A method of mapping abstract identifier implementations organized into namespaces may be used by parties (e.g., software developers) to combine identifier implementations with maximum flexibility, producing high-performance abstract code tailored to different application requirements and host binding environments. By expressing a bound entity via a parenthetical construct, multiple different implementations of the same abstract identifier can be uniquely identified and coexist together within the same program. A similar technique can also be used to uniquely identify extensions to existing types and namespaces developed by external parties without causing binding name clashes.

Abstract: An apparatus, computer system program product and method implement self-healing functionality in a cross development environment to maximize the availability and minimize interoperability problems between disparate software development environments that are coupled to one another via such an environment. In particular, dynamically-modifiable mapping data structures are used to interface multiple software development environments with one another, such that modifications may be made to such data structures in response to modifications made in the underlying software development environments and thereby maintain interoperability between such software development environments.