Abstract: The present invention extends to methods, systems, and computer program products for creating text functions form a spreadsheet. Embodiments of the invention extract functions from spreadsheets and represent the functions in textual form. Representation in textual form promotes code reuse, clarify, expressive power, and better performance. Text can be rendered in virtually any programming language, such as, for example, C#, C++, Visual Basic (“VB”), etc. In some embodiments, programming language extensibility to support spreadsheet compatible data types and functions is utilized.

Abstract: Aspects of this disclosure relate to a method of compiling high-level software instructions to generate low-level software instructions. In an example, the method includes identifying, with a computing device, a set of high-level (HL) control flow (CF) instructions having one or more associated texture load instructions, wherein the set of HL CF instructions comprises one or more branches. The method also includes converting, with the computing device, the identified set of HL CF instructions to low-level (LL) instructions having a predicate structure. The method also includes outputting the converted (LL) instructions having the predicate structure.

Abstract: Methods, apparatus, and products are disclosed for generating an executable version of an application using a distributed compiler operating on a plurality of compute nodes that include: receiving, by each compute node, a portion of source code for an application; compiling, in parallel by each compute node, the portion of the source code received by that compute node into a portion of object code for the application; performing, in parallel by each compute node, inter-procedural analysis on the portion of the object code of the application for that compute node, including sharing results of the inter-procedural analysis among the compute nodes; optimizing, in parallel by each compute node, the portion of the object code of the application for that compute node using the shared results of the inter-procedural analysis; and generating the executable version of the application in dependence upon the optimized portions of the object code of the application.

Abstract: A system and method are disclosed for private cloud computing and for the development and deployment of cloud applications in the private cloud. The private cloud computing system and method of the present invention include as components at least a cloud controller, a cloud stack, Service Registry, and a cloud application builder.

Abstract: A system and method for use with garbage collected systems and languages, for enabling an allocated heap memory to be updated (e.g., increased or decreased) at runtime, subject to sufficient availability of physical memory. In accordance with an embodiment, a Java Virtual Machine (JVM) is associated with a management console, which allows a systems administrator to monitor current heap utilization at runtime. The heap is visualized as a contiguous chunk of memory with one or more extension points, e.g., by use of a trailing pointer to a null list. If later, at runtime, the heap size needs to be incremented then the trailing pointer can be set to a new chunk of memory with a size of (new value?old value), so that the cumulative new size is made equal to a new value specified on the console. The new chunk of memory can again end with a trailing pointer, to allow for further extension.

Abstract: A method and apparatus for processing multimedia instruction enhanced data by the use of an abstract routine generator and a translator. The abstract routine generator takes the multimedia instruction enhanced data and generates abstract routines to compile the multimedia instruction enhanced data. The output of the abstract generator is an abstract representation of the multimedia instruction enhanced data. The translator then takes the abstract representation and produces code for processing.

Abstract: An operating system may be configured using a control flow graph that defines relationships between each executable module. The operating system may be configured by analyzing an application and identifying the operating system modules called from the application, then building a control flow graph for the configuration. The operating system may be deployed to a server or other computer containing only those components identified in the control flow graph. Such a lightweight deployment may be used on a large scale for datacenter servers as well as for small scale deployments on sensors and other devices with little processing power.

Abstract: The present disclosure includes a shader compiler system and method. In an embodiment, a shader compiler includes a decoder to translate an instruction having a vector representation to a unified instruction representation. The shader compiler also includes an encoder to translate an instruction having a unified instruction representation to a processor executable instruction.

Abstract: A method and computer program product for selecting an expression evaluation technique for domain-specific language (DSL) compilation. An application written in DSL for a programming task is provided, the application including a plurality of components configured by expressions. A technique that most quickly implements the programming task is selected from a plurality of techniques for evaluating the expressions. The DSL application is compiled in accordance with the selected expression evaluation technique to generate general-purpose programming language (GPL) code.

Abstract: Mechanisms for aggressively optimizing computer code are provided. With these mechanisms, a compiler determines an optimization to apply to a portion of source code and determines if the optimization as applied to the portion of source code will result in unsafe optimized code that introduces a new source of exceptions being generated by the optimized code. In response to a determination that the optimization is an unsafe optimization, the compiler generates an aggressively compiled code version, in which the unsafe optimization is applied, and a conservatively compiled code version in which the unsafe optimization is not applied. The compiler stores both versions and provides them for execution. Mechanisms are provided for switching between these versions during execution in the event of a failure of the aggressively compiled code version. Moreover, predictive mechanisms are provided for predicting whether such a failure is likely.

Abstract: A computer system includes a processor and program storage coupled to the processor. The program storage stores a software instruction translator that, when executed by the processor, is configured to receive source code and translate the source code to a low-level language. The source code is restricted to a subset of a high-level language and the low-level language is a specialized instruction set. Each statement of the subset of the high-level language directly maps to an instruction of the low-level language.

Abstract: Method for protecting computer software by detecting an attack of an intruding program interfering with the execution of said protected software on a computer system with a processor and at least a processor memory, wherein the computer software to be protected communicates with a license container containing a license for using and executing the protected computer software and containing at least one cryptographic key, wherein the license container provides licenses and cryptographic keys for the protected software to protect its usage and its integrity, and wherein the protected computer software is at least partly encrypted and uses the associated cryptographic keys to decrypt said protected software for executing comprises the following steps: during execution of the protected software, analyzing the behavior of the protected software and/or the execution environment of the protected software on the computer system, and searching for patterns of an intrusion or an intruding program, detecting an intrusion

Abstract: The present invention provides a computer implemented method, apparatus, and computer usable program code for compiling instructions to manage a cache system. Loop constructs are analyzed to identify data usage characteristics for cache and prefetching conditions in instructions to form identified prefetch conditions. A set of control instructions are inserted into the instructions based on the data usage characteristics and the identified prefetch conditions to form multiple modified instructions. The set of multiple modified instructions are compiled to generate code for execution to form compiled instructions. The set of control instructions in the compiled instructions form a cache management policy to control movement of data in a memory system during execution of the compiled instructions.

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: 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 system and method are provided for stacking global variables associated with a plurality of tools. The method includes loading a first tool global variable into a memory and executing a first tool of a computer application, the computer application configured to automate human resource processes. The method includes responsive to a call to execute a second tool of the computer application, pushing the first tool global variable onto a stack. The method includes loading a second tool global variable into the memory and executing the second tool. The method includes responsive to completing execution of the second tool, popping the first tool global variable off the stack and loading the first tool global variable back into the memory.

Abstract: The disclosed embodiments provide a system that facilitates the development and compilation of a software program. During operation, the system obtains a set of compilation units to be used in the software program and a version order associated with a programming language of the compilation units. Next, for each compilation unit from the set of compilation units, the system uses the version order to select a version of the programming language that is compatible with the compilation unit. The system then uses the version to compile the compilation unit.

Abstract: Data Brick is a state of the art solution to access the data through high speed data access mechanism that is exceptionally fast and is associated with low CPU consumption cost. The Data Brick stores relatively static reference data in the form of a programming language Load Module. The Load module contains the data can be launched into the application program memory and this data can be accessed very efficiently in a programming language program. Static application data that is accessed by multiple applications in a mainframe Batch environment is a prime candidate for the Data Brick.

Abstract: A flexible, extensible and efficient compile-time mechanism that leverages native high-level application programming language constructs (e.g., the template and macro features of C++), thus minimizing any programmer or a software developer learning curve and eliminating the need for programming tool (e.g., compiler) changes, to identify and control aspects of shared resource access in concurrent software at the time of source code compilation.

Abstract: An interactive computer architecture is provided that can be employed as a bridge between a mainframe-based computing environment and a distributed server-based computing environment. A request/reply contract can be expressed within the mainframe-based environment and employed as the basis for generating a web service in the distributed computing environment.

Abstract: Detecting locking discipline violations on shared resources. For example, a method of detecting locking discipline violations of shared resources of a computing platform, by a testing process to be executed concurrently with one or more other processes on said computing platform, the testing process comprising: locking a shared resource of said computing platform; reading a value of the shared resource; locally storing the value of the shared resource; rereading the value of the shared resource after a predefined time period; and generating a locking discipline violation report if the value of said shared resource as reread by said rereading is different from the value of said resource as locally stored by said locally storing.

Abstract: System and method for converting a statechart from a first statechart development environment to a second statechart development environment. A first statechart may be received. The first statechart may be created in a first statechart development environment. The first statechart may implement a first functionality. The first statechart may be parsed to determine a plurality of elements of the first statechart. A markup language representation of the first statechart may be generated. The markup language representation may represent the plurality of elements of the first statechart. A second statechart may be generated based on the markup language representation. The second statechart may be in a second statechart development environment. The second statechart may implement the first functionality. The second statechart may be stored.

Abstract: Techniques for performing capacity planning for applications running on a computational infrastructure are provided. The techniques include instrumenting an application under development to receive one or more performance metrics under a physical deployment plan, receiving the one or more performance metrics from the computational infrastructure hosting one or more applications that are currently running, using a predictive inference engine to determine how the application under development can be deployed, and using the determination to perform capacity planning for the applications on the computational infrastructure.

Abstract: A method for compiling a program including a loop is provided. In the program, the loop includes K instructions (K>2) and repeats for M times (M>2). The compiling method comprises following steps: performing resource conflict analysis to the K instructions in the loop; dividing the K instructions in the loop into a first combined instruction section, a connection instruction section and a second combined instruction section, wherein there is no resource conflict between the instructions in the first combined instruction section and the instructions in the second combined instruction section respectively; and compiling the program, wherein the instructions in the first combined instruction section in the cycle N (N=2, 3, . . . M) and the instructions in the second combined instruction section in the cycle N?1 are combined to be compiled respectively. A compiling apparatus and a computer system for realizing the above-mentioned compiling method are further provided.

Abstract: A computer implemented method includes receiving an ordered sequence of programming language statements, identifying a first statement and one or more second statements that are configured to be executed after the first statement, in which the first statement is configured to initiate an asynchronous task that executes asynchronously with respect to the one or more second statements, and configuring the one or more second statements to execute upon completion of the asynchronous task.

Abstract: Provided is a system for distributed multi-stage compilation of application programs in a cloud environment. The system includes a source apparatus to generate a compilation order in which source representation of an application program is compiled, and a destination apparatus to receive a compiled representation created by compiling at least a portion of the source representation according to the compilation order.

Abstract: A computer implemented method including receiving an input, translating the input into a compiled application having a client portion and a server portion, receiving a client portion testing location and a server portion testing location, and instantiating a client virtual machine and a server virtual machine according to the respective client portion testing location and the server portion testing location. The method includes executing the compiled client application portion on the client virtual machine instantiated, executing the compiled server application portion on the server virtual machine instantiated, and monitoring execution of the compiled client and server application portions on the respective client and server virtual machines.

Abstract: Pre-compiling postdominating functions. Some embodiments may be practiced in a computing environment including a runtime compilation. For example one method includes acts for compiling functions. The method includes determining that a function of an application has been called. A control flow graph is used to determine one or more postdominance relationships between the function and one or more other functions. The one or more other functions are assigned to be pre-compiled based on the postdominance relationship.

Abstract: Selected components of a piece of software serve in a first variant, as variation points, are converted into a first XML code. The software, now in hybrid form, is shipped. The first code is converted on the customer side via one or more transformations, for example SLT, exclusively in accordance with transformation rules into a second XML code. In a second variant, a first XML code containing at least one language extension is converted in accordance with transformation rules into a more easily verifiable second XML code without said language extensions. In a third variant a source code formulated in XML is transformed in such a way that, following a back-conversion into the original programming language, a new source code is produced in which not only the representation, but also the actual program content and/or functionality has been changed.

Abstract: A method for executing non-native binaries on a host computer architecture comprises receiving the guest executable binary into a computer readable medium. The guest executable binary is executed on the host computer architecture by translating the guest executable binary into a translated executable binary. Each instruction of the translated executed binary is then executed on the host computer architecture. Signals are responded to by placing signal information on a signal queue and deferring signal handling until a safe point is reached. A computer system implementing the method is also provided.

Abstract: Systems and methods that enhance and balance a late binding and an early binding in a programming language, via supplying an option component to opt-in (or opt-out) late binding, and wherein a late binding is triggered based on a static type for the variable (e.g., object or a type/string.) Additionally, the variable is enabled to have different static types at different regions (e.g., a program fragment) of the programming language.

Abstract: A method for forming an extension to a scripting language compiler is disclosed. A compiler of a machine receives a source code that has a new keyword to a scripting language of the compiler. An extension compiler module processes the source code to support the new keyword. The compiler and the extension compiler module generate an executable machine code based on a process of the extension compiler module and the compiler.

Abstract: A process for generating dynamic type is disclosed. A compiler generated template method including a mark for custom instruction is selected for cloning. Dynamic code is injected at the mark for the custom instructions. The template method including the injected dynamic code is compiled.

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 method and apparatus for the manually optimizing the scheduling of code are disclosed. Accordingly, a software development tool with a graphical user interface enables manually ordering the scheduling of operations for architectures that execute multiple instructions/operations per machine cycle, such as very long instruction word (VLIW) processors. Assistance is provided at the instruction scheduling stage of VLIW compilation process to increase instruction level parallelism (ILP). The apparatus provides graphical views of assembly code and related information. An interactive, user friendly method to manipulate the code during or after scheduling is provided. The programmer can temporarily pause the automated scheduling, override decision taken by the scheduler, and then resume scheduling. The method lets the programmer interact graphically with scheduling decisions in a feedback environment.

Abstract: Optimizing a program having a plurality of functions using an optimization technique that requires breaking a calling convention. A first function of the plurality of functions is modified as a result of optimizing. A name of the first function is mangled to form a unique first mangled name changing the name of the first function to include, as a result of mangling, first information conveying at least in part how the first function was modified. A second function of the plurality of functions, being a caller of the first function, is also modified to correctly invoke the first function using the unique first mangled name to apply the optimization technique. A compilation tool can, after optimizing, use the first information to take a first action with respect to the first procedure, wherein the compilation tool otherwise would require the calling convention to remain unbroken to take the first action.

Abstract: A state component saves a present state of a program or model. This state component can be invoked by the program or model itself, thereby making state a first-class citizen. As the state of the program evolves from the saved state, the saved state remains for reflection and recall, for example, for testing, verification, transaction processing, etc. Using a state reference token, the saved state of the program or model can be accessed by the program or model. For example, the program or model by utilizing a state component, can return itself to the saved state. After returning to the saved state, a second execution path can be introduced without requiring re-execution of the actions leading to the saved state. In another example, the state space of an executing model is saved in order to generate inputs required to exercise a program or model.

Abstract: A method and system are described for generating reference tables in object code which specify the addresses of branches, routines called, and data references used by routines in the code. In a suitably equipped processing system, the reference tables can be passed to a memory management processor which can open the appropriate memory pages to expedite the retrieval of data referenced in the execution pipeline. The disclosed method and system create such reference tables at the beginning of each routine so that the table can be passed to the memory management processor in a suitably equipped processor. Resulting object code also allows processors lacking a suitable memory management processor to skip the reference table, preserving upward compatibility.

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: Disclosed herein are methods and systems for creating and using pre-parsed headers. One or more header files may be scanned into tokens. These tokens may then be parsed into abstract syntax trees. The abstract syntax trees may then be serialized in a modular form into pre-parsed headers on a storage device. Based upon directives in one or more source files, the pre-parsed headers may then be deserialized into abstract syntax trees and loaded from the storage device. The loaded abstract syntax trees may then be used in the compilation of the source files.

Abstract: A compiler compiler system with a design paradigm different from traditional compiler compiler systems in many aspects. First, instead of parsing tree, compiler compiler runtime and binary are designed according to compiler compiler parsing model. Second, any semantics processing is totally separated from syntax processing. Third, the whole compilation process is defined as syntax processing and semantics processing followed by syntax processing performed under compiler compiler management supervision. Fourth, syntax processing has two phases: building compiler compiler runtime, and converting compiler compiler runtime into compiler compiler binary with available option to convert back compiler compiler binary to compiler compiler runtime. Fifth, compiler compiler runtime and binary syntax-controlled APIs are defined in terms of syntax. Sixth, there are formal methods de-compiling compiler compiler runtime and/or binary into original program text accordingly to syntax.

Abstract: A method of creating a form-based web application using a computing device having at least a processor, a memory, a display device and an input device. The method includes retrieving from the memory and providing on the display device a number of form icons, each form icon representing a form to be displayed to a user of the application. The method further includes retrieving from said memory and providing on the display device a number of service icons, each service icon representing a service which may be called in response to actions of the user. The method further includes allowing a developer of the application to use the input device to select one or more of the form icons and one or more of the service icons and to arrange the selected icons on the display device.

Abstract: The subject matter of this specification can be embodied in, among other things, a process that includes receiving, during a computer programming process for a software program, a specification of a software module having a defined functionality for use by the software program. The software module is stored in a central repository having different versions of the software module. The process also includes compiling the software program. The compilation initiates steps including filtering versions of the software module that do not meet the specification. The specification corresponds to more than one version of the software module. The steps also include selecting, from versions that have not been filtered out, a version of the software module. The selection is based on one or more predetermined rules. The process also includes returning the selected version of the software module for local storage with the software program.

Abstract: Methods and apparatus for dynamically adding and deleting new code to previously validated application executing in a secured runtime. New code is written to a portion of secured memory not executable by application. New code is validated to ensure it cannot directly call operating system, address memory outside of secured memory, or modify secured memory state. Indirect branch instructions may only target addresses aligned on fixed size boundaries within the secured memory. Validated code is copied to portion of secured memory executable by application in two stage process that ensures partially copied segments cannot be executed. Validated new code can be deleted once all threads reach safe execution point, provided code was previously inserted as unit or contains no internal targets that can be called by code not also being deleted.

Abstract: Methods and systems to compile a code module to permit a caller routine to pass a parameter to a callee routine of a separately compiled code module, and to permit a callee routine to receive a parameter from a caller routine of the separately compiled code module, through multiple interfaces. Interfaces may include an interface by convention and an alternate interface. A caller routine may be configured to pass a parameter through an alternate interface and call to an alternate entry point of a callee routine. An associated stub routine may be configured to pass the parameter through an interface by convention and to call to a conventional entry point of the callee routine. If the callee routine includes a corresponding alternate entry point, the caller routine may be linked to the alternate entry point. Otherwise, the callee routine may be linked to the callee routine through the stub routine.

Abstract: A firmware extension method is provided, particularly adaptable for an embedded system. Firstly, a baseline firmware image is provided with a header file. Secondly, an extension firmware image is generated based on the header file, comprising one or more extended functions. Thereafter, a callback table is generated, comprising pointers pointing to entries of the extended functions in the extension firmware image. Further, memory allocation parameters are provided. The memory allocation parameters comprise a base address where the extension firmware image starts. The baseline firmware image, the extension firmware image and the callback table are then merged to generate a merged firmware image based on the memory allocation parameters.

Abstract: A compiler supporting a language in which selected semantic objects are represented as data objects. The data objects may be used in multiple ways to expand the capabilities of the programming language. Data objects may be passed to applications and used to create executable instructions for that application. In this way, instructions written in the native language of the compiler may be used to control applications that accept programs in a language inconsistent with the native language of the compiler. The syntax checking and variable binding capabilities of the compiler may be used for those instructions that will be executed by an application separate from the object code generated by the compiler. The semantic objects represented as data objects may be selected based on express operations included in the source code or may be based on implicit type conversion.

Abstract: Mechanisms for intermixing code are provided. Source code is received for compilation using an extended Application Binary Interface (ABI) that extends a legacy ABI and uses a different register configuration than the legacy ABI. First compiled code is generated based on the source code, the first compiled code comprising code for accommodating the difference in register configurations used by the extended ABI and the legacy ABI. The first compiled code and second compiled code are intermixed to generate intermixed code, the second compiled code being compiled code that uses the legacy ABI. The intermixed code comprises at least one call instruction that is one of a call from the first compiled code to the second compiled code or a call from the second compiled code to the first compiled code. The code for accommodating the difference in register configurations is associated with the at least one call instruction.

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 virtual machine can be extended to be aware of secondary cores and specific capabilities of the secondary cores. If a unit of platform-independent code (e.g., a function, a method, a package, a library, etc.) is more suitable to be run on a secondary core, the primary core can package the unit of platform-independent code (“code unit”) and associated data according to the ISA of the secondary core. The primary core can then offload the code unit to an interpreter associated with the secondary core to execute the code unit.