Abstract: A mechanism for determining support criteria for shared libraries based on their priority levels is described. A method of embodiments of the invention includes extracting interface provisioning detail relating to interfaces associated with shared libraries provided by an operating system running on a computer system. The interfaces include application binary interfaces (ABIs). The method further includes detecting interface usage detail associated with the interfaces. The interface usage detail is based on a frequency at which one or more interfaces are used by one or more third-party software programs running on the operating system. The method further includes comparing the interface provisioning detail with the interface usage detail to determine an importance level of each shared library, and analyzing comparison results obtained from the comparison. The analyzing includes assigning a priority level to each shared library based on its importance level.

Abstract: A method, system, and article of manufacture are disclosed for transforming a definition of a process for delivering a service on a specified computing device. This service process definition is comprised of computer readable code. The method comprises the steps of expressing a given set of assumptions in a computer readable code; and transforming the definition by using a processing unit to apply the assumptions to the definition of the process to change the way in which the process operates. The definition of the process may be transformed by using factors relating to the specific context in or for which the definition is executed. Also, the definition may be transformed by identifying, in a flow diagram for the process, flows to which the assumptions apply, and applying program rewriting techniques to those identified flows.

Abstract: Various domains may wish to specify different implementations of the type; e.g., a compilation domain may describe the type statically, an execution domain may instantiate objects of the given type, while a debugging execution domain may associate additional debugging information such as a symbol name. This may be achieved by specifying a type implementation of a particular type within respective domains which all implement a common type interface. A type binding instruction set may then select a type implementation for the type within the target instruction set according to the domain, and may bind type instances of the type within target instruction set to the selected type implementation for the current domain. This technique yields domain-specific variance in type implementation without having to reconfigure the target instruction set or perform domain-checking logic there-within.

Abstract: A runtime system implemented in accordance with the present invention provides an application platform for parallel-processing computer systems. Such a runtime system enables users to leverage the computational power of parallel-processing computer systems to accelerate/optimize numeric and array-intensive computations in their application programs. This enables greatly increased performance of high-performance computing (HPC) applications.

Abstract: One embodiment of the present invention provides a system that improves program performance by enregistering memory locations. During operation, the system receives program object code which has been generated to use a specified number of registers that are available for a given target hardware implementation. Next, the system translates this object code to execute on a second hardware implementation which includes more registers than the first hardware implementation. The system uses these additional registers to improve the performance of the translated object code for the second hardware implementation. More specifically, the system identifies a memory access in the object code, and then rewrites an instruction associated with this memory access to access an available register instead of the original target memory location. To preserve program semantics, the system subsequently moderates accesses to the memory location to ensure that no threads access a stale value in the enregistered memory location.

Abstract: Methods, apparati, and computer-readable media for updating proxy executable code. An apparatus embodiment of the present invention comprises generic universal proxy executable code that can be instantiated multiple times, with each instance being driven by a different set of files comprising a protocol specification file and a proxy activity code file, to control protocol decomposition and proxy functions, respectively. In a method embodiment of the present invention, a protocol specification is created or updated; proxy activity code, separate from the protocol specification, is created or updated; and the proxy executable code is executed using the protocol specification and the proxy activity code.

Abstract: A virtual execution system that is configured to be used in a resource-constrained device. The resource-constrained device includes an operating system and an application program that includes instructions. The virtual execution system includes an execution engine that is configured to execute the application program, and to facilitate the compatibility of the application program with the operating system. Non-functional aspects characterize the instructions and the operating system. The execution engine has access to the non-functional aspects, and implements improvements during the execution of the application program based on the non-functional aspects.

Abstract: A method for providing an application by a virtual machine. The method includes a step of compiling an application written in a source code to a native application for a particular platform and a step of transforming the compiled application into a library, wherein the library is made available to the virtual machine.

Abstract: A method and an apparatus that instructs a compiler server to build or otherwise obtain a compiled code corresponding to a compilation request received from an application are described. The compiler server may be configured to compile source codes for a plurality of independent applications, each running in a separate process, using a plurality of independent compilers, each running in a separate compiler process. A search may be performed in a cache for a compiled code that satisfies a compilation request received from an application. A reply message including the compiled code can be provided for the application, wherein the compiled code is compiled in direct response to the request, or is obtained from the cache if the search identifies in the cache the compiled code that satisfies the compilation request.

Abstract: A method and apparatus for providing a management interface to an application server to allow user access to managed properties of a deployment. In one embodiment, the method includes receiving metadata of a deployment describing managed properties, which are generated according to a user definition. The method further includes creating a management interface for the deployment to provide user access to the managed properties.

Abstract: A system and method for automatic efficient parallelization of code combined with hardware transactional memory support. A software application may contain a transaction synchronization region (TSR) utilizing lock and unlock transaction synchronization function calls for a shared region of memory within a shared memory. The TSR is replaced with two portions of code. The first portion comprises hardware transactional memory primitives in place of lock and unlock function calls. Also, the first portion ensures no other transaction is accessing the shared region without disabling existing hardware transactional memory support. The second portion performs a fail routine, which utilizes lock and unlock transaction synchronization primitives in response to an indication that a failure occurs within said first portion.

Abstract: A computer readable medium comprises executable instructions to: provide an SDK to a client computer comprising executable instructions for communicating with a build server, receive an HTML/Javascript source application and a configuration file referencing one or more source application files over a computer network from a client computer to the build server, transmit the HTML/Javascript source application and configuration file to multiple compile servers corresponding to each of multiple mobile device platforms, combine the HTML/Javascript source application with a mobile device platform specific framework source code for each mobile device platform on each compile server, compile the HTML/Javascript source application and framework source code on the compile server to output an executable native application for each mobile device platform, and transmit each executable native application from the compile server to the client computer over a computer network.

Abstract: A computer implemented method analyzing a first code in a first managed computer language and generating intermediate code in a completed language. The intermediate code into linking code that allows the second code in a second managed runtime language to interact with the first code.

Abstract: Methods, systems, and computer program products are disclosed for dynamically integrating software resources (such as web services and other back-end software resources) using the services of a content framework (such as a portal platform). A portlet model is leveraged to allow programmatic portlets to serve as proxies for web services, thereby extending portlets beyond their traditional visual role. A deployment interface and a system interface are described for these portlet proxies. The deployment interface is used for composing new web services, and a composition tool is described. The system interface allows for run-time management of the web services by the portal platform. The service provider for a particular function may be bound to the portlet proxy at development time or at run-time.

Abstract: A capability for limited customization that utilizes existing virtual dispatch table technology and allows selective customization is provided. Such a capability combines the usage of virtual dispatch tables with both customized and non-customized code to reduce, or even eliminate over-customization. Further, such a capability may employ a runtime system that decides what methods to customize based on several factors including, but not limited to the size of a class hierarchy, the amount of available space for compiled code, and the amount of available time for compilation.

Abstract: Creating and executing platform portable code. A method includes declaring an object as being a dynamic object in a program. The program is a program compiled using a static language, except that the dynamic object is excluded from static analysis on the object when the program is compiled. The dynamic object includes a dependent call to a platform specific API. The platform specific API is available on one or more platforms to which a compiled version of the program will be deployed, but not available on one or more other platforms to which the compiled version of the program will be deployed.

Abstract: Computer-executed transformation of source code enables optimization of the code for one or more of parallelism, locality, and memory footprint of operations represented in the source code on a computing apparatus. This Abstract is provided for the sole purpose of complying with the Abstract requirement rules that allow a reader to quickly ascertain the subject matter of the disclosure contained herein. This Abstract is submitted with the explicit understanding that it will not be used to interpret or to limit the scope or the meaning of the claims.

Abstract: The subject matter of this specification can be implemented in, among other things, a computer-implemented method for accessing a native application programming interface (API) of a computing device including receiving on the computing device one or more control objects from a first application written in a device-independent programming language. The control objects define a context for accessing the native API and the control objects include at least one control script. The method further includes compiling the control script on the computing device into a second application that is native to the operating system of the computing device. The method further includes executing the second application on the computing device. The executed second application accesses the native API of the computing device to generate an output through a hardware interface of the computing device based on the context.

Abstract: A process for dynamically generating browser-ready code from a high-level code description of a web page written in a first predefined language having one or more adaptive features and from one or more constraints associated with a request for such browser-ready code.

Abstract: The deployment of native methods in a virtual machine environment may be significantly simplified by incorporating a corresponding native code segment into the application file, such as a JAVA class file, and using the embedded native code segment for library bind operations of the corresponding class file.

Abstract: The present invention teaches a variety of systems, platforms, applications, and methods, and relates to mobile platforms, embedded native applications, Java virtual machines, user interfaces, and the like. The present invention discloses a mobile platform which unifies the worlds of the Java virtual machine and native applications to provide a unified and consistent environment for multitasking both Java and native applications within a mobile device.

Abstract: A programming environment may have an abstract interface definition that may contain a redirection definition that may cause a call to be bound to a redirected method or function. The redirected method or function may be a conditional redirection, and some embodiments may perform various checks including signature checks, static and runtime access checks, and other verifications for the redirected method. The redirection may enable a programmer to modify a portion of an interface without having to re-implement all of the functions of the interface.

Abstract: The present invention extends to methods, systems, and computer program products for binding executable code at runtime. Embodiments of the invention include late binding of specified aspects of code to improve execution performance. A runtime dynamically binds lower level code based on runtime information to optimize execution of a higher level algorithm. Aspects of a higher level algorithm having a requisite (e.g., higher) impact on execution performance can be targeted for late binding. Improved performance can be achieved with minimal runtime costs using late binding for aspects having the requisite execution performance impact.

Abstract: A system for providing an assembler for a microprocessor has a file which contains data describing the instruction set of the microprocessor. A translation device for translating into machine language accesses the instruction set descriptors to constrain the machine code output of the assembler to conform to the architecture of the instruction set.

Abstract: A system and method for automated conversion of a SAS runtime macro language (RML) program to a target language program such as JAVA. RML macros are identified and converted for inclusion in the RML program. A lexer is applied to generate a stream of tokens, including a token type for ambiguous tokens. A context dependent parsing module, including a token filter to resolve ambiguous tokens, assists the parser in generating an abstract syntax tree (AST), which is modified to express RML specific control flow constructs with target language program elements. The elements of the modified AST are replaced with target language templates from a library, with template parameters filled from the corresponding AST element. A run time library is provided for execution of the target language program.

Abstract: A method and system encodes data objects and their metadata. An implementation provides a method and system for rewriting a program to encode metadata in the run-time environment of the program and to add run-time checks to the program. An implementation provides a method for serializing a data object according to the encoding method and a method for deserializing a bit sequence that is generated by the serialization method.

Abstract: A runtime system implemented in accordance with the present invention provides an application platform for parallel-processing computer systems. Such a runtime system enables users to leverage the computational power of parallel-processing computer systems to accelerate/optimize numeric and array-intensive computations in their application programs. This enables greatly increased performance of high-performance computing (HPC) applications.

Abstract: A runtime system implemented in accordance with the present invention provides an application platform for parallel-processing computer systems. Such a runtime system enables users to leverage the computational power of parallel-processing computer systems to accelerate/optimize numeric and array-intensive computations in their application programs. This enables greatly increased performance of high-performance computing (HPC) applications.

Abstract: Systems and methods are provided for creating a data structure associated with a software application that is based on at least one framework. According to the method, source code and at least one configuration file of the software application is analyzed by at least one framework-specific processor so as to determine entry point information indicating entry points in the source code, request attribute access information indicating where attributes attached to a request data structure are read and written, and forward information indicating forwards performed by the software application. A data structure for a static analysis engine is created based on this information. The data structure includes a list of synthetic methods that model framework-related behavior of the software application, and a list of entry points indicating the synthetic methods and/or application methods of the software application that can be invoked by the framework.

Abstract: Methods and systems for activating an add-on software component independently of any host application with which the add-on component is compatible are described. Consistent with some embodiments, an add-on manager module can be invoked from any host application that is part of a suite of applications. The add-on manager module displays a list of add-on components that are installed, and compatible with a particular host application. After receiving product activation data (e.g., serial number or product key) for a particular installed add-on component, a license verification operation is performed to validate the product activation data, and activate the add-on component for use with a host application.

Abstract: Methods and apparatus for analyzing the interface usage and requirements within software applications. In one embodiment, the interfaces comprise application programming interfaces (APIs) used with Java-based software, and the apparatus comprises a computer program that analyzes file paths (or classpaths) containing one or more files comprising Java bytecode. The names of the classes are extracted and placed into a class dictionary. The different classes listed in the dictionaries are broken down into their individual methods. Each method is then dissembled and analyzed for method or field invocations on other classes found in the dictionary. Methods called are added to a “used class” report. The used class report preferably contains the name of the class, method and the instruction information.

Abstract: A system and method for early platform dependency preparation of intermediate code representation during bytecode compilation in a virtual machine (VM), or other runtime environment, and particularly for use in a system that includes a Java Virtual Machine (JVM). Current techniques for separating the platform dependent intermediate representation from the platform independent intermediate representation using a watertight abstraction layer gives non-optimal side effects (such as compiler source code duplication or inefficiency in the generated code). Embodiments of the present invention enable the compiler to construct platform dependent idioms using medium level intermediate code, and maintain the platform dependent construct all the way to the final native code.

Abstract: A system and method for rearranging algebraic expressions occurring in program code based on a scheme of ranking operands. The system scans program code to identify an algebraic expression specified by the program code. The expression includes binary operations, scalar operands and at least one array operand. The system operates on the algebraic expression to obtain a final expression by: computing a rank for each of the operands; and performing algebraic transformations on selected subexpressions of the algebraic expression so that in the final expression operands are combined in the order of their rank. The ranking scheme may be designed to force scalars to be combined before arrays, and/or, to force constants to be combined first, loop invariants second, and variants last. In some embodiments, the ranking scheme is a vector ranking scheme including two or more components (such as invariance rank, dimensional rank and data-size rank).

Abstract: Methods, systems, and computer program products are disclosed for dynamically integrating software resources (such as web services and other back-end software resources) using the services of a content framework (such as a portal platform). A portlet model is leveraged to allow programmatic portlets to serve as proxies for web services, thereby extending portlets beyond their traditional visual role. A deployment interface and a system interface are described for these portlet proxies. The deployment interface is used for composing new web services, and a composition tool is described. The system interface allows for run-time management of the web services by the portal platform. The service provider for a particular function may be bound to the portlet proxy at development time or at run-time.

Abstract: A method for communicating between at least one environment-independent application logic code (AL code) and at least one environment which is a combination of hardware and software. The method includes creating at least one interaction style code (IS code) that is specific to and communicates with the at least one environment, and is provided with an interaction style interface (IS interface) for interfacing an interaction style with said at least one application logic code (AL code). The interaction style interface (IS interface) is independent of and does not specify properties of said at least one environment, and the at least one environment-independent application logic code (AL code) runs unchanged in all environments. The at least one interaction style code (IS code) is operable with all of a graphical user interface, a non-graphical user interface, an HTML-based web browser user interface, and no user interface.

Abstract: The inventive method for controlling access to data which is used by reference in a program execution system (including processes and aims) during the program execution consists in memorising by the system the totality of references obtainable by said program with the aid of means considered legal, before any operation which can be prohibited if it relates to values which are not legal references, in verifying by the system whether said values are amongst the legal references memorized for the program and in accepting or rejecting the operation, respectively.

Abstract: A method for creating a unified binary file that may be executed on a plurality of hardware platforms. The unified binary file includes hardware independent code and a plurality of hardware dependent binary files for a variety of hardware platforms. When the unified binary file is executed on a supported hardware platform, an appropriate hardware dependent file is identified and installed. A method for preparing a software package supported on a plurality of hardware platforms for distribution. A unified binary file is created for each corresponding file of the software package. Each unified binary file includes installation directory information and dependent file information.

Abstract: A control system development platform is provided. The platform includes a shell component adapted to support development of a control systems application. An abstract model is associated with the shell component to facilitate development of the control systems applications.

Abstract: A computer implemented method of facilely releasing a BSE software module adapted for execution by an electronic control unit having an update model of the BSE software and a controller having an embedded desktop model of the BSE software, includes a plurality of autonomously performed steps resulting in the compiling of a plurality of c-files into a library file. A single keyword activated preferred embodiment is disclosed in a MatLab®/Simulink®/Real-Time Workshop® environment.

Abstract: Systems and methods are provided for enabling communication between a composite system providing additional functionality not contained in existing legacy systems and other existing systems using different commands, variables, protocols, methods, or instructions, when data may be located on more than one system. In an embodiment, multiple software layers are used to independently manage different aspects of an application. A business logic layer may be used in an embodiment to facilitate reading/writing operations on data that may be stored locally and/or on external systems using different commands, variables, protocols, methods, or instructions. A backend abstraction layer may be used in an embodiment in conjunction with the business logic layer to facilitate communication with the external systems. A user interface layer may be used in an embodiment to manage a user interface, a portal layer to manage a user context, and a process logic layer to manage a workflow.

Abstract: A method and system for providing access to a shared resource utilizing selective locking are disclosed. According to one embodiment, a method is provided comprising receiving a request to perform a resource access operation on a shared resource, invoking a first routine to perform the resource access operation, detecting a data processing system exception generated in response to invoking the first routine, and invoking a second routine to perform the resource access operation in response to such detecting. In the described embodiment, the first routine comprises a dereference instruction to dereference a pointer to memory associated with the shared resource, the second routine comprises a lock acquisition instruction to acquire a global lock associated with the shared resource prior to a performance of the resource access operation and a lock release instruction to release the global lock once resource access operation has been performed.

Abstract: Code handling, such as interpreting language instructions or performing “just-in-time” compilation, is performed using a heterogeneous processing environment that shares a common memory. In a heterogeneous processing environment that includes a plurality of processors, one of the processors is programmed to perform a dedicated code-handling task, such as perform just-in-time compilation or interpretation of interpreted language instructions, such as Java. The other processors request code handling processing that is performed by the dedicated processor. Speed is achieved using a shared memory map so that the dedicated processor can quickly retrieve data provided by one of the other processors.

Abstract: User assemblies can be created by a compiler that can handle more than one type definition during execution. Local copies are created for respective authoritative types in a code library, and the local copies are marked with a local type identifier. An authoritative type identifier (e.g., a globally unique identifier (GUID)) is copied from the authoritative type to the local type, and functions and properties associated with the local type are also copied from the authoritative type. Authoritative types are resolved for requested types when a local assembly references a local type from a compiled user assembly. The local type can be identified by a local type identifier, and an authoritative type can be retrieved from the code library that has a same authoritative type identifier as the requested type. A local copy of the retrieved authoritative type can be copied to the local assembly under compilation. The compiler can then emit user assemblies that comprise merely local types.

Abstract: An apparatus for processing digital audio-visual data including a module class manager configured to evaluate code to determine an interpretative language in which the code is written, wherein the interpretative language is selected from a plurality of interpretative languages, and an interpreter specific to the interpretative language, wherein the interpreter is configured to interpret and execute the code.

Abstract: A compiler and method of optimizing code by partial inlining of a subset of blocks of called blocks of code into calling blocks of code. A restart of the called blocks of code is provided for the case where non-inlined blocks of code are reached at run time. Blocks selected for partial inlining may include global side effects depending on the computer program environment. Global side effects in the selected blocks of code leading to a restart are sanitized in order to defer changes to the global state of the computer program.

Abstract: A mechanism is disclosed for implementing fast synchronization of simple synchronized methods in a virtual machine. The mechanism provides for determining, during runtime, whether a set of instructions can be fully executed in lieu of invoking a synchronized method, which requires locking of a particular object. The set of instructions provides equivalent functionality to the synchronized method but with less locking overhead. In response to a determination that the set of instructions can be fully executed, the set of instructions is fully executed to achieve equivalent functionality to the synchronized method in lieu of invoking the synchronized method. In response to a determination that the set of instructions cannot be fully executed, the synchronized method is invoked. With this mechanism, simple synchronized methods can be executed with less locking overhead.

Abstract: A method for managing a software application. The method involves receiving an abstract API command to perform a life cycle operation (LCO) on a target system, where the LCO identifies the software application, where the software application is associated with a software application schema, and where the target system is associated with a platform independent registry, determining whether the LCO is compatible with the target system using the software application schema and the platform independent registry, where the LCO is compatible with the target system; mapping the abstract API command to an operating system (OS)-specific command for performing the LCO, where the OS-specific command is associated with an OS executing on the target system; executing the OS-specific API command to perform the LCO on the target system to obtain a result; and updating the platform independent registry based on the result.

Abstract: A runtime system implemented in accordance with the present invention provides an application platform for parallel-processing computer systems. Such a runtime system enables users to leverage the computational power of parallel-processing computer systems to accelerate/optimize numeric and array-intensive computations in their application programs. This enables greatly increased performance of high-performance computing (HPC) applications.

Abstract: A method for implementing architecture cloning including: constructing a program call graph in a link phase of interprocedural analysis to model calling relationships between one or more procedures in a program; analyzing the program call graph to obtain information about the program; analyzing the program to identify the one or more procedures subject to architecture cloning; determining feasibility of architecture cloning; marking the one or more procedures in the program suitable for architecture cloning; naming the one or more procedures in the program suitable for architecture cloning; inserting a runtime routine call at an entry point of the program; invoking architecture cloning when one or more candidate procedures are identified during procedure cloning; providing a user with an interface for specifying multiple architecture targets to the compiler; and enabling the compiler to generate architectural specific instructions optimized for each of the multiple architecture targets.

Abstract: An improved architecture for a program code conversion apparatus and method for generating intermediate representations for program code conversion. The program code conversion apparatus determines which types of IR nodes to generate in an intermediate representation (IR) of subject code (10) to be translated. Depending upon the particular subject and target computing environments involved in the conversion, the program code conversion apparatus utilizes either base nodes, complex nodes, polymorphic nodes, and architecture specific nodes, or some combination thereof, in generating the intermediate representation.