Inventors list

Assignees list

Classification tree browser

Top 100 Inventors

Top 100 Assignees

Compiling code

Subclass of:

717 - Data processing: software development, installation, and management


717136000 - Translation of code

Patent class list (only not empty are listed)

Deeper subclasses:

Class / Patent application numberDescriptionNumber of patent applications / Date published
717151000 Optimization 355
717146000 Including intermediate code 135
717141000 Analysis of code form 114
717149000 For a parallel or multiprocessor system 79
717145000 Including recompilation 15
20130074052RUN TIME INCREMENTAL COMPILATION OF SCRIPT CODE - Scripts are incrementally compiled at runtime to generate executable code. The incremental compilation generates executable code corresponding to a basic block of the script. The executable code for a basic block of script is generated for a set of types of variables of the basic block resulting from execution of the script in response to a request. The generated executable code is stored and executed for subsequent requests if these requests result in the same types of variables for the basic block. The incremental compilation of the script is performed in a lazy fashion, such that executable code is not generated for combinations of types of variables of the script code that are not obtained from requests received at runtime. The script may dynamically generate portions of a web page that is returned in response to a request for execution of the script.03-21-2013
20110209128SYSTEMS, METHODS AND APPARATUSES FOR FACILITATING TARGETED COMPILATION OF SOURCE CODE - Methods, apparatuses, and systems are provided for facilitating targeted compilation of source code. A method may include receiving source code for an application. The method may further include determining information about an execution platform of an end user apparatus on which the application will be executed. The method may additionally include compiling the source code based at least in part on the determined information into an executable targeted to the execution platform of the end user apparatus. The method may also include causing the executable to be sent to the end user apparatus. Corresponding apparatuses and systems are also provided.08-25-2011
20090193400Interprocedural register allocation for global variables - A method of compiling a computer program with interprocedural register allocation for global variables. The method of compiling includes a front-end phase, an interprocedural analysis phase, and a back-end phase. The interprocedural analysis phase receives intermediate representations from the front-end phase, processes the intermediate representations together to compute interprocedural information, and outputs optimized intermediate representations. During the interprocedural analysis phase, a set of eligible global variables are selected for promotion, wherein promotion of the selected eligible global variables comprises replacing memory references to said variables with references to global registers assigned to said variables. Other embodiments, aspects and features are also disclosed.07-30-2009
20130086563COMPILING CODE FOR AN ENHANCED APPLICATION BINARY INTERFACE (ABI) WITH DECODE TIME INSTRUCTION OPTIMIZATION - A code sequence made up multiple instructions and specifying an offset from a base address is identified in an object file. The offset from the base address corresponds to an offset location in a memory configured for storing an address of a variable or data. The identified code sequence is configured to perform a memory reference function or a memory address computation function. It is determined that the offset location is within a specified distance of the base address and that a replacement of the identified code sequence with a replacement code sequence will not alter program semantics. The identified code sequence in the object file is replaced with the replacement code sequence that includes a no-operation (NOP) instruction or having fewer instructions than the identified code sequence. Linked executable code is generated based on the object file and the linked executable code is emitted.04-04-2013
20110202905APPARATUSES, METHODS AND SYSTEMS FOR AN API CALL ABSTRACTOR - The APPARATUSES, METHODS AND SYSTEMS FOR AN API CALL ABSTRACTOR provide live reconciliation of code updates to multi-user social networking applications in highly dynamic build environments (“SNAM”). In one embodiment, an API call abstraction processor-implemented method is disclosed. It includes obtaining programming code for an application and parsing the obtained programming code to identify instructions in the programming code. The SNAM identifies an application programming interface call in the programming code based on parsing the obtained programming code and the application programming interface call including an input string. The SNAM determines if the identified application programming interface call requires a pre-registered bundle to replace the input string. It provides a request to register a new bundle including the input string and obtains an indication that the new bundle has been registered. The SNAM can obtain a bundle identification corresponding to the new bundle, upon obtaining the indication that the bundle has been registered and replace the input string in the application programming interface call with the bundle identification.08-18-2011
20100077387MANAGING UPDATES USING COMPILER AND LINKER INFORMATION - Generating a next build version of a software application using information generated during a previous build version at the compiler and linker levels. The information describes the structure and build decisions applied during creation of the previous build version. Generation of the current build version is modified based on the information to minimize the binary differences between the builds. In some embodiments, a linker arranges the contents during the previous build in anticipation of the current build. Further, the linker pads the previous build with unused address space to minimize relocation of the contents of the build.03-25-2010
20130036409TECHNIQUE FOR COMPILING AND RUNNING HIGH-LEVEL PROGRAMS ON HETEROGENEOUS COMPUTERS - A technique for compiling and running high-level program on heterogeneous computers may include partitioning a program code into two or more logical units, and compiling each of the logical units into one or more executable entities. At least some of the logical units are compiled into two or more executable entities, the two or more executable entities being different compilations of the same logical unit. The two or more executable entities are compatible to run on respective two or more platforms that have different architecture.02-07-2013
20130036408TECHNIQUE FOR COMPILING AND RUNNING HIGH-LEVEL PROGRAMS ON HETEROGENEOUS COMPUTERS - A technique for compiling and running high-level program on heterogeneous computers may include partitioning a program code into two or more logical units, and compiling each of the logical units into one or more executable entities. At least some of the logical units are compiled into two or more executable entities, the two or more executable entities being different compilations of the same logical unit. The two or more executable entities are compatible to run on respective two or more platforms that have different architecture.02-07-2013
20120210308BINDING-BASED CHARACTERIZATION OF CLOSURES IN SOFTWARE PROGRAMS - The disclosed embodiments provide a system that facilitates the compilation and execution of a software program. During operation, the system obtains a closure from source code for the software program. Next, the system characterizes a type of the closure based on a mutability of one or more variables captured by the closure. Finally, the system encodes the type into a compiled form of the closure to facilitate subsequent execution of the closure in a multithreaded environment.08-16-2012
20130047142Thermal-Aware Source Code Compilation - Thermal-aware source code compilation including: receiving, by a compiler, an identification of a target computing system, the identification of the target computing system specifying temperature sensors that measure temperature of a memory module; compiling the source code into an executable application including inserting in the executable application computer program instructions for thermal-aware execution, the computer program instructions, when executed on the target computing system, carry out the steps of: retrieving temperature measurements of one or more of the target computing system's temperature sensors; determining, in real-time in dependence upon the temperature measurements, whether a memory module is overheated; if a memory module is overheated, entering a thermal-aware execution state including, for each memory allocation in the executable application, allocating memory on a different memory module than the overheated memory module; and upon the temperature sensors indicating the memory module is no longer overheated, exiting the thermal-aware execution state.02-21-2013
20110173593Compiler Providing Idiom to Idiom Accelerator - A wake-and-go mechanism may be a programming idiom accelerator. As a processor fetches instructions, the programming idiom accelerator may look ahead to determine whether a programming idiom is coming up in the instruction stream. If the programming idiom accelerator recognizes a programming idiom, the programming idiom accelerator may perform an action to accelerate execution of the programming idiom. A compiler may recognize programming idioms and expose the programming idioms to the programming idiom accelerator within the resulting machine language instructions.07-14-2011
20130074053INFRASTRUCTURE SERVICE ARCHITECTURE FOR APPLICATIONS - A mechanism is disclosed for operating local version-independent service program code for infrastructure services, wherein the mechanism is automatically and optionally linked to a central, remote service infrastructure, and wherein both an online and an offline processing mode is included and automatically supported, and wherein the mechanism is embedded in a generic runtime environment. In at least one embodiment, it contains service program code implemented in the runtime environment for calling by way of the application program code with standardized interfaces, wherein the service program code is intended for the provision of functionalities for predetermined services that an application program code can use.03-21-2013
20090235239BUILD SYSTEM REDIRECT - Embodiments may provide a makefile interposer, which enables a makefile to be used for building software for different platforms without modifying the makefile. In some embodiments, the interposer intercepts the commands run by makefile and automatically interposes the correct library files, dependencies, paths, and other information used by make to build the program for a particular platform. Additionally, calls that the invoked tools themselves make are intercepted and the interposer may redirect them to the platform-specific tools or file system locations including redirecting file descriptors. In some instances, when a tool is called that is not in the platform, the interposer may also fall back on the other system tools.09-17-2009
20090235238CONDENSING PATTERN MATCHER GENERATION FOR INTERMEDIATE LANGUAGE PATTERNS - Embodiments of the present invention address deficiencies of the art in respect to pattern matcher generation and provide a method, system and computer program product for automatic pattern matching and generation of intermediate language patterns. In one embodiment of the invention, a pattern matcher generation method can be provided. The method can include identifying input elements from intermediate language code, reducing the identified input elements from the intermediate language code to inputs of common and unique use, creating a unifiable form for each of the input elements of common and unique use, and generating a pattern matcher for each of the input elements of common and unique use in the intermediate language code using a corresponding unifiable form in place of each of the input elements of common and unique use. In particular, the generated pattern matcher can be EMTF conformant.09-17-2009
20130167126IN-ORDER EXECUTION IN AN ASYNCHRONOUS PROGRAMMING ENVIRONMENT - 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.06-27-2013
20130167127SYSTEM, APPARATUS, AND METHOD FOR DISTRIBUTED COMPILATION OF APPLICATIONS - 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.06-27-2013
20110283268Mechanism for Cross-Building Support Using Dependency Information - A mechanism for cross-building support using dependency information is disclosed. A method of the invention includes parsing a source code package received for compilation into a binary source code package for a target machine, the parsing to determine a list of dependency packages needed to compile the source code package, for each dependency package in the list of dependency packages determining a type of the dependency package and associating an architecture of at least one of a build machine compiling the source code package or the target machine with the dependency package based on a determined type of the dependency package, downloading each dependency package in the list of dependency packages in a binary form of the build architecture format, and downloading each dependency package that is associated with the target machine in a binary form of the target architecture format.11-17-2011
20090064112TECHNIQUE FOR ALLOCATING REGISTER TO VARIABLE FOR COMPILING - The present invention relates to allocating registers to variables in order to compile a program. In an embodiment of the present invention a compiler apparatus stores interference information indicating an interference relationship between variables, selects a register and allocates the register to each variables in accordance with a predetermined procedure, without allocating the same register to a set of variables having interference relationships. The compiler further replaces multiple variables having the same register allocated thereto with a new variable and generates an interference relationship by merging the interference relationships each concerning one of multiple variables. The compiler further updates interference information according to the generated interference relationship and allocates to each variable in the program using the new variable a register, selected in accordance with the predetermined procedure without allocating the same register to a set of variables having the interference relationships, based on the updated interference information.03-05-2009
20110289491Method and Device for Program Installation - A method for installing an application program is disclosed. The method includes detecting a system platform, and detecting preprocessing software required by the application program according to the system platform and a compilation script and accordingly generating a relationship file and a log file, wherein the log file includes an acquisition method for the preprocessing software.11-24-2011
20110289492PROGRAM CODE GENERATION SUPPORT DEVICE AND METHOD, PROGRAM EXECUTION DEVICE AND METHOD, AND PROGRAM CODE COMPRESSION PROCESSING DEVICE AND METHOD AND PROGRAM THEREOF - To obtain a program code generation support device, method, and the like, capable of generating a new program code, in particular, generating in accordance with an incorporating apparatus, by performing a further optimization on a program code. The device includes storage means for storing as data, an optimization rule that is composed of a conversion condition for converting data of a program code and a conversion content thereof, and code optimization means that includes a code analysis unit for analyzing the program code, a condition search unit for search a part matching the conversion condition in the program code through a collation with the optimization rule stored in the storage means on the basis of the analyzed program code, and an optimization unit for generating data of a new program code by converting the part matching the conversion condition on the basis of the conversion content.11-24-2011
20100088685SYSTEM AND METHOD FOR MAPPING A DOMAIN MODELING LANGUAGE TO A RELATIONAL STORE - A method and system for mapping between constructs in a domain modeling language and a relational storage language is provided. A source code authored in a source language is received and a set of constructs in the source code are identified. The set of constructs in the source code are mapped to a set of constructs in a target language. The source code is then compiled into a target code authored in the target language such that one of the source code or target code include a declarative constraint-based and/or order-independent execution model.04-08-2010
20110191755Method and apparatus providing COBOL decimal type arithmetic functions with improved performance - A method and apparatus is disclosed providing an improvement in performance for arithmetic computations by a computer system for calculations which include decimal numeric variables. The improvement in at least one embodiment includes use of a special compiler in cooperation with a special decimal numeric subroutine library. The compiler provides comparative alignment information based upon comparing alignments of a plurality of decimal variables. The decimal subroutine library can then provide improved performance at run time by utilizing the information compared by the compiler at compiler time rather than making those computations repeatedly at run time.08-04-2011
20110219363METHOD FOR DYNAMICALLY LINKING PROGRAM ON EMBEDDED PLATFORM AND EMBEDDED PLATFORM - The examples of the present invention disclose a method for dynamically linking a program on an embedded platform and an embedded platform. The embedded platform includes a middle layer which comprises at least one class. An application program to be linked includes at least one class. The application program is compiled into PICs, wherein storage positions of different code sections in the PICs which are obtained by compiling different functions of the application program do not overlap with each other; all the PICs are copied into a memory of the embedded operation system; a class pointer is created, and the class pointer is transferred between the class of the middle layer and the class of the application program to dynamically link the application program.09-08-2011
20100169869Supporting method references in the JAVA language - According to one embodiment of the invention, the JAVA compiler is modified so that when the JAVA compiler determines, while compiling source code, that an invocation of a first method, which expects to receive a reference to an object, passes, to the first method, a reference to a second method instead of a reference to an object, the JAVA compiler does not issue a compile-time error as the JAVA compiler normally would. Instead, the JAVA compiler generates compiled code (e.g., byte code) that the JAVA compiler would have generated if the source code had (a) defined a “bridge” class that implemented a method that invoked the second method and (b) contained, in the invocation of the first method, a reference to an object that was an instance of the “bridge” class in the place of the reference to the second method.07-01-2010
20100275187IMPLEMENTING A CLASS ORIENTED DATA FLOW PROGRAM ON A PROGRAMMABLE HARDWARE ELEMENT - System and method for converting a class oriented data flow program to a structure oriented data flow program. A first data flow program is received, where the first data flow program is an object oriented program comprising instances of one or more classes, and wherein the first data flow program is executable to perform a first function. The first data flow program is automatically converted to a second data flow program, where the second data flow program does not include the instances of the one or more classes, and where the second data flow program is executable to perform the first function. The second data flow program is stored on a computer memory, where the second data flow program is configured to be deployed to a device, e.g., a programmable hardware element, and where the second data flow program is executable on the device to perform the first function.10-28-2010
20100070954CUSTOM DATABASE SYSTEM AND METHOD OF BUILDING AND OPERATING THE SAME - A process for performing a software task is detailed that includes preparing readable programming computer code and storing the computer code within the storage of a computer system in uncompiled form. The computer code is compiled to machine code in response to an executional call for the code. The machine code corresponding to the computer code is then executed to perform the software task. In addition to removing the conventional limitation of retaining only executable compiled software, only a portion of a larger total computer code necessary to perform the desired software task is compiled in response to an executional call from a user, request for another computer process, a prompt by an interfaced electronic instrument or a boot event.03-18-2010
20110246973COMPILER SUPPORTING PROGRAMS AS DATA OBJECTS - 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.10-06-2011
20100122241Executable template - Systems, methods, and other embodiments associated with executable templates are described. One example method includes generating an executable template from a set of template data. When an executable template is executed, the executable template creates one or more instantiated entities. These instantiated entities may then be combined with entities created from portions of the original template that were not compilable into the executable format.05-13-2010
20090328014COMPILER BASED CODE MODIFICATION FOR USE IN DOCUMENT RANKING - The subject matter disclosed herein relates to alter an expression of executable instructions via a compiler component for use in ranking of electronic documents.12-31-2009
20090089763SHADER COMPILE SYSTEM AND METHOD - 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.04-02-2009
20110126179Method and System for Dynamic Patching Software Using Source Code - Systems and methods for extracting an original source code for an application, the original source code including source code for a function, receiving source code for a new function, the source code being a same type as the original source code, the new function to replace the function in the application, determining information from one of the original source code and an execution of the application and transforming the source code for the new function into transformed source code based on the information determined from the original source code.05-26-2011
20080244539ENABLING ANALYSIS OF SOFTWARE SOURCE CODE - A source code clarification system is described. In various embodiments, the source code clarification system receives clarified source code and transforms the clarified source code into standard source code or object code that implements asynchronous components. The standard software source code can contain expressions for enabling asynchronous communications. The clarified code can be software source code that is expressed in an imperative language and is capable of static analysis. The clarified source code can contain a coordination primitive that encapsulates interactions between asynchronous components. By using the coordination primitives and events, the clarified source code can express interactions between asynchronous components so that the clarified source code is easier for developers to understand and for static analysis tools to analyze.10-02-2008
20090328013COMPONENTIZATION OF COMPILER FUNCTIONALITY - Compiler functionality is componentized to enable use across different contexts. Conventionally tightly coupled functionality is decoupled and an interface afforded to facilitate interaction with compiler components/subcomponents in various scenarios. In one instance, compiler components can be employed across compile time and runtime. Compile time functionality can be employed at runtime and runtime functionality utilized at compile time thereby blurring the line between time dimensions.12-31-2009
20090328012COMPILER IN A MANAGED APPLICATION CONTEXT - A batch compiler is employed to enable compilation of code provided at runtime. A managed application receives code during execution and invokes the compiler to transform the code to enable it to execute within the context of the receiving application. Among other things, employment of a batch compiler preserves investments made to such compilers while also opening up new scenarios in application scripting and/or hosting that are otherwise unavailable.12-31-2009
20100146493METHOD AND SYSTEM FOR PLATFORM-INDEPENDENT FILE SYSTEM INTERACTION - Embodiments disclosed can provide a simple, singular programmatic interface for application developers to access and manipulate ASCII and non-ASCII file specifications in a cross-platform development environment regardless of operating system encoding capabilities or of the nature of the original file specification encoding. An application development environment is configured on a computer system such that a magic class file string object is instantiated when a bit string of a first encoding is received. The bit string represents a file specification of a file containing application code written by an application developer. The magic class file string object automatically determines what target operating system is being called by a function call in the application code, automatically transcodes the bit string from the first encoding into a second encoding of the target operating system, and automatically makes a correct file system API call specific to the target operating system.06-10-2010
20110209127Register Allocation With SIMD Architecture Using Write Masks - A single instruction multiple data processor may accomplish register allocation by identifying live ranges that have incompatible write masks during compilation. Then, edges are added in an interference graph between live ranges that have incompatible masks so that those live ranges will not be assigned to the same physical register.08-25-2011
20120198426METHODS AND APPARATUS TO FORM A RESILIENT OBJECTIVE INSTRUCTION CONSTRUCT - Methods and an apparatus to form a resilient objective instruction construct are provided. An example method obtains a source instruction construct and forms a resilient objective instruction construct by compiling one or more resilient transactions.08-02-2012
20090144708MULTI-ATTRIBUTE DYNAMIC LINK LIBRARY PACKAGING - A system for packaging a dynamically linked computer program function includes a compiler configured to compile a source file iteratively to create a plurality of corresponding object files, the source file associated with a specific computer program function having an established an attribute, with each attribute exhibiting a plurality of at least one of variations, characteristics and parameters, wherein each iteration of the compiling the source file results in the plurality of object files having the specific computer program function but with each object file having distinct attributes from one another; and a linker configured to link the plurality of resulting object files to create a single executable file, such that the single executable file comprises different versions of the specific computer program function; and wherein the single executable file is configured to facilitate choice of a selected version of the specific computer function.06-04-2009
20100205587METHOD, DEVICE AND SYSTEM FOR REALIZING KERNEL ONLINE PATCHING - A method, a device, and a system for realizing kernel online patching are provided. The method includes loading a pre-generated patch file in an operating system, setting a first breakpoint at an execution start position of the primitive function when a system thread executes the primitive function and a breakpoint exception occurs during the thread execution process due to the first breakpoint, modifying a returning execution address of the first breakpoint into the destination address of the patch function corresponding to the primitive function according to the first corresponding relation, and removing the first breakpoint. The kernel online patching implementation has a small impact on the normal operation of the operating system. The patch function becomes valid without restarting the operating system, thereby satisfying the high reliability requirements of carrier-class products.08-12-2010
20090083720EMPLOYING IDENTIFIERS PROVIDED BY AN OPERATING SYSTEM OF A PROCESSING ENVIRONMENT TO OPTIMIZE THE PROCESSING ENVIRONMENT - Optimizations are provided for processing environments. Selected memory objects are tagged with unique identifiers by an operating system of the environment, and those identifiers are used to manage processing within the environment. By detecting by a processing platform of the environment that a memory object has been tagged with a unique identifier, certain tasks may be bypassed and/or memory objects may be reused, even if located at a different location.03-26-2009
20090049430Verifying that binary object file has been generated from source files - For a source file on which basis a binary object file has been generated, a digital signature is generated for the source file, and the digital signature is stored. The digital signature may be secure hash algorithm (SHA) hash values. The binary object file is output. To verify that the binary object file has been generated from the source file, a digital signature is generated for the source file, and compared to the digital signature for the source file as previously stored. Where the digital signature for the source file as has been generated matches the digital signature for the source file previously stored, the binary object file is indicated as having been generated from the source file.02-19-2009
20090055810Method And System For Compilation And Execution Of Software Codes - The method and system disclosed herein is for compiling and executing a plurality of software codes. The requests from users are parsed and loaded using a set of child processes or a thread pool. A request handler is used to handle the compilation and execution requests from the user. Requests from a plurality of client processes are listed to compile and execute the solution codes from a plurality of users. A set of common libraries and system libraries for each compilation request are stored in a memory and loaded on to a compiler. Using the stored common libraries and system libraries, an executable binary format of the software code is created by the compiler. The executable binary format of the software code is loaded on a file system for further executions.02-26-2009
20090055809Binary Library - 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.02-26-2009
20090210864Method and array for changing software or source code - 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. Alternatively, in a fourth variant a source code formulated in XML with, for example, initial states, code fragments to be replaced and foreign language modules tailored to the respective natural language of the user is mixed by transformation, as a result of which, following a back-conversion, a new source code is produced in which not only the representation, but also the actual program content and/or functionality has been changed.08-20-2009
20090249313System and Method for Prioritizing the Compilation of Bytecode Modules During Installation of a Software Application - A system and method for compiling part of the bytecode for a software application into native code at install time when the software application is installed on a particular computer are described. According to one embodiment of the method, usage information for the software application may be received. The usage information may indicate how frequently or commonly each of a plurality of features of the software application is used. The usage information may be analyzed to determine a rank ordering of the features. The method may further comprise installing the software application on the particular computer. Installing the software application may comprise compiling one or more bytecode modules of the software application into native code, where the one or more bytecode modules are selected from a plurality of bytecode modules depending upon the rank ordering of the features.10-01-2009
20090249315OBJECT STORAGE AND SYNCHRONIZATION HOOKS FOR OCCASIONALLY-CONNECTED DEVICES - A system may include an application programming interface (API) layer, a cache layer, and an object storage/access layer. The API layer may expose an interface to store a business object and an interface to retrieve the business object, and may transmit a request to store the business object and a request to retrieve the business object, and the cache layer may cache the business object and transmit the request to store the business object and the request to retrieve the business object. The object storage/access layer may receive the request to store the business object and, in response to the request to store the business object, to invoke a serialization method exposed by the business object to store the data associated with the object in a data structure. The object storage/access layer may also receive the request to retrieve the business object and, in response to the request to retrieve the business object, to invoke a deserialization method of the business object to deserialize the data associated with the business object in the data structure.10-01-2009
20090249314COMPUTER ASSISTED DATA COLLECTION FOR SURVEYS AND THE LIKE - An exemplary MMIC (“Multi-Mode Interviewing Capability”) survey program is a computerized tool that supports various traditional modes of collecting interview data, including telephone interviewing, written interviewing, and personal interviewing, and can be used to manage the whole interview process from questionnaire design, sample management, and fieldwork monitoring to final dataset production. The collected data may also include non-textual data from survey participants such as medical measurements of blood pressure and heart rate. Self-interviewing using the Internet is also possible which permits real time availability of results and the participation of respondents from virtually anywhere in the world, using devices such as PDA's, Smart phones and Web TV's. The MMIC survey structure is non-linear and object oriented, which permits a connection between all the building blocks of the survey to be defined on any level. The compiled survey includes sufficient metadata to facilitate decompilation and the production of equivalent source code in any supported programming language, whether or not it was originally programmed in that language. This stored metadata not only allows researchers to later trace back the exact conditions under which this particular answer was given, but also permits results from multiple iterations of the related surveys to be combined in a rigorous manner that will be transparent to subsequent analysis and research.10-01-2009
20120131561Model-based Programming, Configuration, and Integration of Networked Enbedded Devices - Embodiments of the invention relate to programming, configuring, and integrating networked embedded devices with other applications. Particular embodiments include an architecture having an application model layer that integrates the networked embedded devices with business application systems, by allowing the devices to be expressed as part of a business application concept. In certain embodiments, an intermediate device programming layer provides a network-centric programming abstraction, relieving the programmer of the details of low-level, node-centric programming. Finally, a self-optimizing run-time system layer adapts to the specific conditions in the deployed network embedded devices, by optimizing e.g. communication patterns and resource consumption based upon input from the higher layer(s). Embodiments may facilitate integration of networked embedded devices with the back ends of business applications, and may provide a unified extensible programming framework simplifying development of applications for network embedded devices.05-24-2012
20090249312Process Generation Approach and System for an Integrated Telecom Platform - An approach for process generation for computer telephony integration (CTI) of an integrated telecom platform, including the following steps. Step 1: The process input module receives the flow chart input by a user and saves it as a flow chart record file; Step 2: the process coversion module coverts the flow chart record file into the equivalent source codes and saves them as a flow chart coversion output file; Step 3: the process compilation module compiles the flow chart coversion output file and saves it as a flow chart compilation output file. The invention also announces a process generation system for an integrated telecom platform, including the process input module, the process coversion module and the process compilation module. The invention is an ideal system for various CTI applications, allowing easy and fast subsequent development as well as convenient system upgrade and maintenance.10-01-2009
20100153931 Operand Data Structure For Block Computation - In response to receiving pre-processed code, a compiler identifies a code section that is not a candidate for acceleration and a code block that is a candidate for acceleration. The code block specifies an iterated operation having a first operand and a second operand, where each of multiple first operands and each of multiple second operands for the iterated operation has a defined addressing relationship. In response to the identifying, the compiler generates post-processed code containing lower level instruction(s) corresponding to the identified code section and creates and outputs an operand data structure separate from the post-processed code. The operand data structure specifies the defined addressing relationship for the multiple first operands and for the multiple second operands. The compiler places a block computation command in the post-processed code that invokes processing of the operand data structure to compute operand addresses.06-17-2010
20100180265FIRMWARE EXTENSION METHOD AND FIRMWARE BUILDER - 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. The baseline firmware image, the extension firmware image and the callback table are then merged to generate a merged firmware image.07-15-2010
20100192135Method and Structure to Develop a Test Program for Semiconductor Integrated Circuits - Test program development for a semiconductor test system, such as automated test equipment (ATE), using object-oriented constructs is described. The invention provides a method for describing test system resources, test system configuration, module configuration, test sequence, test plan, test condition, test pattern, and timing information in general-purpose object-oriented constructs, e.g., C++ objects and classes. In particular, the modularity of program development is suitable for developing test programs for an open architecture semiconductor test system.07-29-2010
20120198425MANAGEMENT OF CONDITIONAL BRANCHES WITHIN A DATA PARALLEL SYSTEM - A compiler of a single instruction multiple data (SIMD) information handling system (IHS) identifies “if-then-else” statements that offer opportunity for conditional branch conversion. The compiler converts those “if-then-else” statements into “conditional branch and prepare” statements as well as “branch return” statements. The compiler compiles source code file information containing “if-then-else” statement opportunities into compiled code, namely an executable program. The SIMD IHS employs a processor or processors to execute the executable program. During execution, the processor generates and updates SIMD lane mask information to track and manage the conditional branch loops of the executing program. The processor saves branch addresses and employs SIMD lane masks to identify conditional branch loops with different branch conditions than previous conditional branch loops. The processor may reduce SIMD IHS processing time during processing of compiled code of the original “if-then-else” statements. The processor continues processing next statements inline after all SIMD lanes are complete, while providing speculative and parallel processing capability for multiple data operations of the executable program.08-02-2012
20100180266Multi Level Virtual Function Tables - A multi level virtual function table uses a hierarchy of chunks or segments of virtual function tables to identify methods for a particular class. At least one level of indirection pointers may point to individual virtual function table chunks, which may be shared by multiple classes. In some embodiments, fixed size chunks of virtual function tables may be used, other embodiments may use variable sized chunks of virtual function tables. In just in time compiled code, virtual function tables may be limited to sharing across parent and child classes, while in pre-compiled code, more complex sharing may be used.07-15-2010
20100205585FAST VECTOR MASKING ALGORITHM FOR CONDITIONAL DATA SELECTION IN SIMD ARCHITECTURES - Techniques are disclosed for generating fast vector masking SIMD code corresponding to source code having a conditional statement, where the SIMD code replaces the conditional statements with vector SIMD operations. One technique includes performing conditional masking using vector operations, bit masking operations, and bitwise logical operations. The need for conditional statements in SIMD code is thereby removed, allowing SIMD hardware to avoid having to use branch prediction. This reduces the number of pipeline stalls and results in increased utilization of the SIMD computational units.08-12-2010
20100211937 INTERMEDIATE FORM FOR BITWIDTH SENSITIVE APPLICATIONS AND USES THEREOF - Techniques for representing a program are provided. The techniques include creating one or more sub-variables for each of one or more variables in the program, and maintaining a single size of each of the one or more variables throughout a life-span of each of the one or more variables. Additionally, techniques for performing register allocation are also provided. The techniques include representing bit-width information of each of one or more variables in a powers-of-two representation, wherein the one or more variables comprise one or more variables in a program, coalescing the one or more variables, packing the one or more coalesced variables, and using the one or more packed variables to perform register allocation.08-19-2010
20110119657USING FUNCTION CALLS AS COMPILER DIRECTIVES - A method for passing compiler directives into a compiler wherein empty function calls are defined, which call no function, but define compiler directives by its name, is suggested. Thus, by allowing empty functions calls and by handling them automatically, in particular in the automated way suggested, significant improvements over the prior art can be obtained.05-19-2011
20110113409SYMBOL CAPABILITIES SUPPORT WITHIN ELF - Systems and methods for efficient compilation and execution of program code. A compiler generates a plurality of families of object files, wherein each family comprises a set of system capabilities different from a set of another family. A link-editor receives the object files and stores a symbol capabilities table in a symbol capabilities section of an object file with a new file format. A symbol is associated with one or more instances, wherein each instance is associated with a different set of capabilities. In various embodiments, system capabilities may include a particular operating system, special-function additional instructions, or otherwise. Subsequent to creation of the single object file with multiple instances of a given function, a runtime linker chooses a given instance based on the capabilities of the platform on which the code is to be executed.05-12-2011
20090328011SAFE CODE FOR SIGNATURE UPDATES IN AN INTRUSION PREVENTION SYSTEM - Described is a technology by which a signature used by network traffic intrusion prevention/detection systems includes logic that helps a prevention/detection engine detect that signature. A signature to detect is compiled into executable logic that is executed to communicate with an engine that evaluates network traffic. The signature logic provides an expression set (such as group of regular expressions) for the engine to match against a token corresponding to the network traffic. When matched, the engine notifies the logic and receives a further expression set to match, or a communication indicative that that the signature was detected. The signature thus directs the analysis, facilitating a lightweight, generic engine. Safety of the signature logic is described as being accomplished through layers, including by publisher signing, and by compilation and execution (e.g., interpretation) in safe environments.12-31-2009
20110067012SYSTEM AND METHOD FOR GENERATING WHITE-BOX IMPLEMENTATIONS OF SOFTWARE APPLICATIONS - A development suite for generating files, such as DRM-protected files, using white-box cryptography. The suite consists of a code generation tool, a data transformation engine, and a white-box data generation tool, and a white-box library. In the white-box cryptography context, the data transformation engine is used to protect the boundary between the cryptographic operation and the surrounding code. In particular, the data transformation engine is used to apply data transformations to the inputs to and outputs from the cryptographic operations. If the user specifies that transformations are required via a white-box parameterization file, the code generation tool puts the information specified by the user into a form the data transformation engine understands, namely as qualifiers on data variables and function prototypes. The data transformation engine then applies the specified transformations, and passes information to the data generation tool regarding which transformations were chosen.03-17-2011
20110067011TRANSFORMATION OF SINGLE-THREADED CODE TO SPECULATIVE PRECOMPUTATION ENABLED CODE - In one embodiment a thread management method identifies in a main program a set of instructions that can be dynamically activated as speculative precomputation threads. A wait/sleep operation is performed on the speculative precomputation threads between thread creation and activation, and progress of non-speculative threads is gauged through monitoring a set of global variables, allowing the speculative precomputation threads to determine its relative progress with respect to non-speculative threads.03-17-2011
20100223602METHODS AND TOOLS FOR CREATION OF READ-ONLY-MEMORY SOFTWARE BINARY IMAGES AND CORRESPONDING SORTWARE PATCHES - There are described tools and methodologies for building Read Only Memory (ROM) mask software images and the corresponding data/code patching software images. One method is for creating ROM mask content having patch references included therein whereby patch reference errors are detected and corrected. A software patch for a ROM mask with existing patch references may then automatically be created.09-02-2010
20090150872DYNAMIC CODE UPDATE - A process for updating a computer program is provided in which a code update procedure is performed during the execution of one or more components of the program by an execution environment that is operable to execute a plurality of program components in a plurality of sequential frames of execution. The execution environment is further operable to: i) allow communication between one of the components and another of the components in different frames of execution; and ii) prevent communication between one of the components and another of the components in the same frame of execution. The code update procedure is performed at a frame transition between adjacent frames of execution.06-11-2009
20090113402SERVER-BASED CODE COMPILATION - A server is disclosed that includes an interface to a data communication network, a compiler library that stores a plurality of different compilers, and compiler selection logic responsive to data received at the interface and including logic. The compiler selection logic is configured to select one of the plurality of different compilers based on an evaluation of the received data. The selected compiler generates compiled output data and the compiled output data is communicated over the data communication network to a client.04-30-2009
20110119658SPECULATIVE COMPILATION - The invention is a method and apparatus for use in developing a program. More particularly, a method and apparatus for compiling a source code program during editing of the same is disclosed, where editing can be initial entry or modification subsequent to initial s entry. The method comprises compiling at least a portion of a source code program defined by a waypoint during the editing of the source code program. In other aspects, the invention includes a program storage medium encoded with instructions that, when executed, perform this method and a computer programmed to perform this method. The apparatus includes a computing apparatus, comprising a text editor through which a source code program may be entered; and a compiler that may compile the source code program. The control block is capable of determining at least one waypoint in the source code program and invoking the compiler to compile the source code program up to the waypoint.05-19-2011
20100306748COMPILER AND COMPILING METHOD FOR A NETWORKED CONTROL SYSTEM COMPRISING A PLURALITY OF DEVICES - The invention relates to a compiler and a method for compiling control logic for a plurality of devices of a networked control system, particularly to the automated assignment of control logic to devices. The invention provides with a compilation an automatic assignment procedure of an executable runtime code to devices of a networked control system. The assignment process of control logic to the devices may take various optimization criteria into account which include various distribution aspects, e.g. network resources or capabilities, such as available bandwidth or reliability of the network links, and device resources or capabilities, e.g. CPU, memory, power source or sleeping behaviour which may influence the observed behaviour of the devices, e.g. due to transmission delay or data packet loss.12-02-2010
20090070750Distributed parallel build system - This document describes, among other things, systems and methods for managing distributed parallel builds. A computer-implemented method to manage parallel builds, comprises identifying one or more software components in a software project, wherein each software component includes an executable binary file; determining a build configuration for each software component, wherein the build configuration includes a mapping from each software component to one or more build servers; and building each software component using the mapped one or more build servers in the corresponding build configuration, wherein the building includes compiling one or more source files associated with each software component to one or more object files, by distributing the one or more source files to one or more compilation machines.03-12-2009
20130145353FIRMWARE EXTENSION METHOD AND FIRMWARE BUILDER - 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.06-06-2013
20100180264HANDLING MULTIPLE DEFINITION OF TYPES - 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.07-15-2010
20110035732Method and apparatus for defining and compiling or converting language and user interface system agnostic view definitions to runnable code - A method of converting a declaratively defined and language & user interface platform agnostic view to source or binary computer code that is then used to display the view at application run-time. The method includes processing of the view definition, reading the component definition for each component defined in the view, loading and executing each component builder code module to retrieve the output code for each component, and then integrating the output code for each component into a single output for the view. The method allows for new components to be introduced to the system, unknown at the time of the system's packaging, and it provides means for the view to be fully declarative in nature, including no software instructions of any kind.02-10-2011
20110078669Source code protection - A method comprising encrypting an original plain text file and making it available to a user as a protected file, and issuing to said user a user program and a user licence to enable said user to decrypt the protected file and view an image of the original file whilst preventing the image of the original file from being copied to any file, other than as a further protected file. The image is preferably stored in a memory not backed up to the computer swap file. Preferably, the user program comprises an editor program and the user saves editorial changes to the original image in an encrypted difference file, separate from the original file. Both files are then used to re-create the edited image using the editor program and user licence. The user program may comprise any computer tool including compilers. Alternatively, the user program comprises a special editor program incorporating an obfuscator which generates obfuscated code from the image generated by the editor program, so that this is only intelligible to a compiler or similar tool capable of converting the obfuscated code to an object file.03-31-2011
20090037889SPECULATIVE CODE MOTION FOR MEMORY LATENCY HIDING - Various embodiments that may be used in performing speculative code motion for memory latency hiding are disclosed. One embodiment comprises extracting an asynchronous signal from a memory access instruction in a program to represent a latency of the memory access instruction, and generating a wait instruction to wait the asynchronous signal.02-05-2009
20090217251METHOD AND APPARATUS FOR CONFIGURING, AND COMPILING CODE FOR, A COMMUNICATIONS TEST SET-UP - Computer-readable code stored on computer-readable media includes code to allocate at least one data structure in computer memory. The at least one data structure has a plurality of message parameter fields, and each of the message parameter fields has a deterministic position within the at least one data structure. The computer-readable code also includes code to navigate to different ones of the message parameter fields by interpreting non-compiled instructions. The instructions have a form that specifies a position of a particular message parameter field within the at least one data structure, and a number of bits in the particular message parameter field. The position of the particular message parameter field is specified in terms of a number of data offsets in the at least one data structure. The computer-readable code also includes code to configure a communications test-set following navigation to at least one of the message parameter fields.08-27-2009
20100251225COMPUTER READABLE RECORDING MEDIUM STORING EXECUTABLE PROGRAM, EXECUTABLE PROGRAM GENERATING APPARATUS, AND EXECUTABLE PROGRAM GENERATING METHOD - A recording medium storing a computer readable resource-bound program for instructing the computer to execute processing, the resource-bound program including receiving an execution start instruction, initiating the executable program when the execution start instruction is an execution instruction for the executable program including a resource used for generating an executable program, and extracting and outputting the resource when the execution start instruction is an output instruction of the resource.09-30-2010
20120304159HARDWARE SUPPORT FOR HASHTABLES IN DYNAMIC LANGUAGES - The aspects enable a computing device to execute traditionally software-based JavaScript® operations in hardware. Each JavaScript® object is hashed into a master hashtable that may be stored in the software. A portion of the software hashtable may be pushed to a hardware hashtable using special instruction set registers dedicated to hashtable processing. Each time a software process requests a hashtable operation (e.g., lookup) the hardware hashtable is checked to determine if the value exists in hardware. If the requested value is in the hardware hashtable, the requested value is accessed in a single operation step. If the requested value is not in the hardware hashtable, the requested value is extracted from the master hashtable in the software and a portion of the master hashtable containing the extracted value is pushed to the hardware using special instruction set registers.11-29-2012
20110252409METHODS AND SYSTEMS TO IMPLEMENT NON-ABI CONFORMING FEATURES ACROSS UNSEEN INTERFACES - 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.10-13-2011
20110035734System and method for effectively processing software changes - This invention discloses a software development system that includes a user input device, a compiler, a build microprocessor and a data storage. The data storage stores a built program built by the build microprocessor by packaging a plurality of heterogeneous program units comprises at least a binary program-unit processed by the compiler and at least a non-compiled program unit inputted by a user to the built microprocessor through the user input device. The program unit to be compiled into binary program unit and the non-compiled program unit stored in the data storage are programmed by at least two different programming languages.02-10-2011
20110035733Software Self-Defense Systems and Methods - Systems and methods are disclosed for protecting a computer program from unauthorized analysis and modification. Obfuscation transformations can be applied to the computer program's local structure, control graph, and/or data structure to render the program more difficult to understand and/or modify. Tamper-resistance mechanisms can be incorporated into the computer program to detect attempts to tamper with the program's operation. Once an attempt to tamper with the computer program is detected, the computer program reports it to an external agent, ceases normal operation, and/or reverses any modifications made by the attempted tampering. The computer program can also be watermarked to facilitate identification of its owner. The obfuscation, tamper-resistance, and watermarking transformations can be applied to the computer program's source code, object code, or executable image.02-10-2011
20110161941CREATION OF FORM-BASED APPLICATIONS - A method of creating a form-based application using a computing device having at least a processor, a memory, a display device and an input device, includes: 06-30-2011
20100070953COMPILER SYSTEM AND A METHOD OF COMPILING A SOURCE CODE INTO AN ENCRYPTED MACHINE LANGUAGE CODE - A compiler system including a compiler configured to compile a source code into a machine language code is presented, so that the machine language code is executable on a processing unit, wherein the processing unit comprises an internal register that is changing its state responsive to an execution of the machine language code. The compiler is configured to encrypt the machine language code based on an encryption function that depends on the state of the internal register.03-18-2010
20110154305SYSTEM AND METHOD FOR REMOTELY COMPILING MULTI-PLATFORM NATIVE APPLICATIONS FOR MOBILE DEVICES - 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.06-23-2011
20110154304DETERMINING COMPILER EFFICIENCY - There is provided a computer implemented method for determining the efficiency of a runtime compiler. A set of execution times representing the time taken for program code to perform a set task after two or more runtime compilations is recorded. A first metric as the difference between the first execution time and the last execution time of the set of execution times, a second metric as the average throughput improvement from the set of execution times, and a third metric as the time taken for the compiler to achieve the maximum throughput from the set of execution times is calculated. Finally, an efficiency metric is calculated using the first, second and third metrics to determine the efficiency of the compiler.06-23-2011
20110154302ADDING SERVICES TO APPLICATION PLATFORM VIA EXTENSION - Systems and methods for adding services to an application platform via an extension platform coupled to the application platform. The application platform runs in a first operation system process and provides a number of resources. The extension platform is implemented in a second operation system process and communicates with the application platforms via standard inter-process communication protocols. The extension platform provides an environment to dynamically model and host application services. A resource abstraction layer provides the extension platform with access to the resources provided at the application platform. The resources are utilized by the extension platform to design and to execute the application services. The application services hosted in the extension platform are centrally managed and administered from the application platform via exposed interfaces.06-23-2011
20110154303Endian Conversion Tool - In one embodiment of the invention code (e.g., compiler, tool) may generate information so a first code portion, which includes a pointer value in a first endian format (e.g., big endian), can be properly initialized and executed on a platform having a second endian format (e.g., little endian). Also, various embodiments of the invention may identify problematic regions of code (e.g., source code) where a particular byte order is cast away through void pointers.06-23-2011
20080320453TYPE INFERENCE AND LATE BINDING - A type inference option is available for a computer programming language. The option acts as a switch to specify whether or not type inference is applicable (e.g., on or off). Type inference can be employed in conjunction with late binding or options therefor. In this manner, a computer program can be developed with the convenience of type inference and the flexibility of late binding while still maintaining at a degree of type safety.12-25-2008
20080229291Compiler Implemented Software Cache Apparatus and Method in which Non-Aliased Explicitly Fetched Data are Excluded - A compiler implemented software cache apparatus and method in which non-aliased explicitly fetched data are excluded are provided. With the mechanisms of the illustrative embodiments, a compiler uses a forward data flow analysis to prove that there is no alias between the cached data and explicitly fetched data. Explicitly fetched data that has no alias in the cached data are excluded from the software cache. Explicitly fetched data that has aliases in the cached data are allowed to be stored in the software cache. In this way, there is no runtime overhead to maintain the correctness of the two copies of data. Moreover, the number of lines of the software cache that must be protected from eviction is decreased. This leads to a decrease in the amount of computation cycles required by the cache miss handler when evicting cache lines during cache miss handling.09-18-2008
20110179402METHOD AND SYSTEM FOR COMPILING A DYNAMICALLY-TYPED METHOD INVOCATION IN A STATICALLY-TYPED PROGRAMMING LANGUAGE - A method for compiling source code, involving: obtaining a statement of the source code comprising a method call, where the source code is composed in a statically-typed programming language; determining whether the method call is a dynamic method call; upon determining that the method call is a dynamic method call, compiling a dynamic method invocation without performing type checking on the method call; upon determining that the method call is not a dynamic method call: performing type checking on the method call, selecting a target method to invoke, and compiling a static method invocation to invoke the target method.07-21-2011
20120311548METHOD AND APPARATUS TO DEVELOP AN APPLICATION OF AN IMAGE FORMING APPARATUS - A solution providing tools for developing an application of an image forming apparatus is stored in the image forming apparatus, and functions of the image forming apparatus are displayed according to execution of the solution. An application corresponding to input information of a user is generated by combining functions of the image forming apparatus based on the input information of the user and is stored in the image forming apparatus.12-06-2012
20120311547SYSTEM AND METHOD FOR PERVASIVE SOFTWARE PLATFORM-BASED MODEL DRIVEN ARCHITECTURE TRANSACTION AWARE APPLICATION GENERATOR - In developing applications for a plurality of node types, a meta-data definition of the application can be captured into an application definition module. The meta-data definition can describe the application for the plurality of node types. A code generation module can then automatically generate the application code for the plurality of node types, including transaction aware code. The code can be compiled per node type and the packaging necessary to deploy the application to the plurality of node types can also be automatically generated.12-06-2012
20110047533Generating Code Adapted for Interlinking Legacy Scalar Code and Extended Vector Code - 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.02-24-2011
20100325617Compiling a Graphical Program Having a Textual Language Program Portion for a Real Time Target - Compiling a graphical program including a textual program portion for execution on a real time target. The graphical program may be created on a display or stored in a memory medium. The graphical program may include a plurality of connected nodes which visually indicate functionality of the graphical program. The graphical program may include at least one node which corresponds to a textual language program portion. The textual language program portion may be written or specified in a dynamically typed programming language. The graphical program may be compiled for deployment on the real time target. Compiling the graphical program may include compiling the plurality of connected nodes and the textual language program portion for deterministic real time execution on the real time target.12-23-2010
20100293533INCREMENTALLY CONSTRUCTING EXECUTABLE CODE FOR COMPONENT-BASED APPLICATIONS - One embodiment of a method for constructing executable code for a component-based application includes receiving a request to compile source code for the component-based application, wherein the request identifies the source code, and wherein the source code comprises a plurality of source code components, each of the source code components implementing a different component of the application, and performing a series of steps for each source code component where the series of steps includes: deriving a signature for the source code component, retrieving a stored signature corresponding to a currently available instance of executable code for the source code component, comparing the derived signature with the stored signature, compiling the source code component into the executable code when the derived signature does not match the stored signature, and obtaining the executable code for the source code component from a repository when the derived signature matches the stored signature.11-18-2010
20100293532FAILURE RECOVERY FOR STREAM PROCESSING APPLICATIONS - In one embodiment, the invention is a method and apparatus for failure recovery for stream processing applications. One embodiment of a method for providing a failure recovery mechanism for a stream processing application includes receiving source code for the stream processing application, wherein the source code defines a fault tolerance policy for each of the components of the stream processing application, and wherein respective fault tolerance policies defined for at least two of the plurality of components are different, generating a sequence of instructions for converting the state(s) of the component(s) into a checkpoint file comprising a sequence of storable bits on a periodic basis, according to a frequency defined in the fault tolerance policy, initiating execution of the stream processing application, and storing the checkpoint file, during execution of the stream processing application, at a location that is accessible after failure recovery.11-18-2010
20100333076PROGRAMMING LANGUAGE TRANSLATOR - A computer readable medium stores a program, executable by a computer, for enabling translation of machine-centric commands in an instrument protocol to a programming language for controlling an instrument configured to use the machine-centric commands. The computer readable medium includes an identifying code segment for identifying instrument protocol commands executable by the instrument, and a generating code segment generates methods corresponding to the instrument protocol commands, each method including programming language source code or compiled machine code for executing the corresponding instrument protocol command. A storing code segment stores the methods in a program library associated with the instrument, the program library enabling selection of at least one method by a programming language program that controls the instrument, in order to execute the instrument protocol command corresponding to the selected method.12-30-2010
20100180267PLC COMPILING SYSTEM AND COMPILING METHOD - A programmable logic controller (PLC) compiling system includes a ladder diagram loading unit, an instruction set loading unit storing instruction sets, an instruction compiling unit, an operating system loading unit storing dynamic link library (DLL) file templates based on a number of operating systems, and a DLL file compiling unit. The ladder diagram loading unit loads and stores predetermined ladder diagrams. The instruction compiling unit loads the predetermined ladder diagrams and the instruction sets, and compiles the predetermined ladder diagrams to a plurality of instructions corresponding to the instruction sets accordingly. The DLL file compiling unit loads the compiled instructions and the DLL file templates, and compiles the compiled instructions to a plurality of DLL files based on the DLL file templates to match the instruction sets accordingly.07-15-2010
20100180268ARITHMETIC UNIT, PROCESSOR, COMPILER AND COMPILING METHOD - An arithmetic unit which includes: a data supply section which supplies floating-point type object data to which a sign is to be added and condition data which includes a condition under which the sign is added; a sign data generating section which extracts the condition included in the condition data and generates sign data for adding the sign to the object data on the basis of the extracted condition; and an integer arithmetic operation section which performs an integer arithmetic operation while treating the object data as integer type data so as to add the sign to the object data on the basis of the sign data and the object data.07-15-2010
20110138371COMPILING DEVICE AND COMPILING METHOD - According to an embodiment, a compiling device compiling a source program written so as to use a frame memory includes a processing delay amount calculator configured to calculate respective processing delay amounts between a plurality of process tasks in the source program on the basis of processing states of pieces of data processed by the process tasks. The compiling device also includes a line memory amount calculator configured to calculate respective line memory sizes required for each of the process tasks on the basis of an access range of a frame memory from which the process task reads data and an instruction code converter configured to convert the plurality of process tasks to instruction codes executable in a pipeline on the basis of the processing delay amounts and the line memory sizes.06-09-2011
20090300590STATICALLY SPECULATIVE COMPILATION AND EXECUTION - A system, for use with a compiler architecture framework, includes performing a statically speculative compilation process to extract and use speculative static information, encoding the speculative static information in an instruction set architecture of a processor, and executing a compiled computer program using the speculative static information, wherein executing supports static speculation driven mechanisms and controls.12-03-2009
20090300589Electronic Crime Detection and Tracking - A system for electronic crime reduction is provided, comprising a computer system, a database, a malware de-compiler, a malware parser, and an inference engine. The database contains information that associates electronic crime attack signature data with at least one of an individual, a group, and a location. The malware de-compiler, when executed on the computer system, translates a first malware executable to an assembly language version. The first malware is associated with an electronic crime that has been committed. The malware parser, when executed on the computer system, analyzes the assembly language version to identify distinctive coding preferences used to develop the first malware. The inference engine, when executed on the computer system, analyzes the distinctive coding preferences identified by the malware parser application in combination with searching the database to identify one of an individual, a group, and a location associated with the electronic crime.12-03-2009
20090083719METHOD OF COMPILING MACHINE CODE PROGRAM FOR PROGRAMMABLE LOGIC CONTROLLER - A method of compiling machine code program for programmable logic controller (PLC) reads a PLC program such as a ladder diagram program. The mnemonics codes in the PLC program are searched and checked with syntax correctness regarding PLC logic rule. When all of the mnemonics codes have correct syntax, the PLC program is converted to a C language program and the C language program is then converted into a C language object program. The C language object program is linked with a library file. When the link is successful, the linked program is directly converted into a machine language program for operation of PLC to access external input/output points (EXIO).03-26-2009
20110307874CREATING TEXT FUNCTIONS FROM A SPREADSHEET - 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.12-15-2011
20090055808LOAD TIME RESOLUTION FOR DYNAMIC BINDING LANGUAGES - Embodiments of the present invention address deficiencies of the art in respect to load time resolutions and provide a method, system and computer program product for load time resolution of AOT compiled class references in a dynamic binding executing environment. In one embodiment of the invention, a method of resolving class references in AOT compiled code can be provided. The method can include updating AOT code at loading time for already resolved class references in the AOT code, and executing the updated AOT code to resolve remaining unresolved class references in the updated AOT code.02-26-2009
20090083721REGISTER ALLOCATION BY PUZZLE SOLVING - We show that register allocation can be viewed as solving a collection of puzzles. We model the register file as a puzzle board and the program variables as puzzle pieces. We model pre-coloring by letting some of the puzzle pieces be already immovably placed on the puzzle board, and we model register aliasing by letting pieces have a plurality widths. For a wide variety of computer architectures, we can solve the puzzles in polynomial time. Puzzle solving is independent of spilling, that is, puzzle solving can be combined with a wide variety of approaches to spilling.03-26-2009
20120210307USAGE ANALYSIS OF PRODUCTIVE ENVIRONMENT TO ESTABLISH NEW DATA SOURCE FOR PROCESS OPTIMIZATION AND PROJECT PLANNING - Systems and methods to provide usage analysis of a productive environment are provided. In example embodiments, a logging module links to a compiler to obtain information on a program as the program is being executed by the compiler. One or more procedures of the program may be determined and a count for each of the one or more determined procedures maintained. The determined one or more procedures and the count for each of the one or more determined procedures are stored in a buffer as log data. The log data is compiled, using one or more processors, into a detailed data source for further analysis.08-16-2012
20120005660Type Inference of Partially-Specified Parameterized Types - A compiler receives source code for a program and determines that the code includes a declaration expression and an initialization expression in an assignment context. The declaration expression introduces a variable and specifies part of a parameterized type for the variable but not another part of the parameterized type. A parameterized type may include a ground type part and one or more type arguments; in a declaration expression, the specified part of the parameterized type may include a ground type and the unspecified part may include one or more of the type arguments. The initialization expression specifies an initial value for the variable, where the value has a parameterized type. The assignment context associates the declared variable with the initial value. The compiler infers the type for the variable based at least on the part specified in the declaration expression and on the type specified by the initialization expression.01-05-2012
20110167414SYSTEM AND METHOD FOR OBFUSCATION BY COMMON FUNCTION AND COMMON FUNCTION PROTOTYPE - Disclosed herein are systems, methods, and computer-readable storage media for obfuscating by a common function. A system configured to practice the method identifies a set of functions in source code, generates a transformed set of functions by transforming each function of the set of functions to accept a uniform set of arguments and return a uniform type, and merges the transformed set of functions into a single recursive function. The single recursive function can allocate memory in the heap. The stack can contain a pointer to the allocated memory in the heap. The single recursive function can include instructions for creating and explicitly managing a virtual stack in the heap. The virtual stack can emulate what would happen to the real stack if one of the set of functions was called. The system can further compile the source code including the single recursive function.07-07-2011
20120017203Path-Sensitive Analysis for Reducing Rollback Overheads - A mechanism is provided for path-sensitive analysis for reducing rollback overheads. The mechanism receives, in a compiler, program code to be compiled to form compiled code. The mechanism divides the code into basic blocks. The mechanism then determines a restore register set for each of the one or more basic blocks to form one or more restore register sets. The mechanism then stores the one or more register sets such that responsive to a rollback during execution of the compiled code. A rollback routine identifies a restore register set from the one or more restore register sets and restores registers identified in the identified restore register set.01-19-2012
20080256522Automobile Controller, Software Generation Method and Software Generation System Thereof - In a processing description part 10-16-2008
20120060150HIGH PERFORMANCE EXECUTION IN WORKFLOW BPM ENGINE - An apparatus and a method for executing a workflow in a business process management (BPM) engine is described. A business process management (BPM) process definition is generated based on a business process at a BPM generator of a BPM system. The BPM process definition is translated into a Java source code at a translator engine of the BPM system. The Java source code is compiled into a Java byte code at a compiler engine of the BPM engine. The processing device of the BPM system is configured to execute the Java byte code.03-08-2012
20120159463METHOD AND SYSTEM FOR CREATING, APPLYING, AND REMOVING A SOFTWARE FIX - Embodiments of the present disclosure involve a method for creating, applying, and removing a software fix for an application without terminating the application. To create the fix, the system converts an unresolved internal reference in a source code section to an external imported reference, generates a header file which includes a re-definition of the external imported reference, and generates a binary representation for the fix by compiling the source code section using the generated header file and linking the complied object. To apply the fix, the system loads the binary representation into a virtual address space, places a long jump operator in a compiler-generated padding prior to the start of an affected function, and replaces a no-operation prologue at the start of the function with a short jump operator in an atomic write operation. To remove the fix, the system replaces the short jump operator with the no-operation prologue, removes the long jump operator, and unloads the software fix.06-21-2012
20120159462METHOD FOR CHECKPOINTING AND RESTORING PROGRAM STATE - Techniques are described that enable restoring interrupted program execution from a checkpoint without the need for cooperation from the computer's operating system. These techniques can be implemented by modifying existing code using an automated tool that adds instructions for enabling restoring interrupted program execution.06-21-2012
20120072889Distributed Graphical Program Execution Using A Handheld Computer - A system and method for deploying one or more graphical programs on a personal digital assistant (PDA). One or more selected graphical programs may be programmatically converted to an executable format that can be executed by the portable computing device. For example, the graphical programs may be initially represented as a plurality of data structures that define or specify the operation of the respective graphical programs, and conversion software program may operate to access these data structures from memory and convert the data structures to an executable format suitable for the portable computing device. The executable may be transferred to the portable computing device for execution.03-22-2012
20120110558CUSTOMIZED BINARIES ON-THE-FLY - One or more techniques and/or systems are disclosed for dynamically generating a customized binary on the fly, without a build process. One or more customizing resources are identified for a requested binary, such as from customizing parameter identified from a decoded binary request that was sent from a client computer at runtime. Using an injection map, a location for one or more customizing resources used to customized the requested binary are identified on a resource server, which can be provided by the binary provider. The customized binary is generated by injecting the one or more customizing resources retrieved from the resource server into a decoded base binary.05-03-2012
20120124563COMPILER SUPPORT TECHNIQUE FOR HARDWARE TRANSACTIONAL MEMORY SYSTEMS - A method and apparatus for compiling software written to be executed on a microprocessor that supports at least one hardware transactional memory function is provided. A compiler that supports at least one software transactional memory function is adapted to include a runtime system that maps between the at least one software transactional memory function and the at least one hardware transactional memory instruction.05-17-2012
20120124562Application Programming Interface Naming Using Collaborative Services - A method, computer system, and computer program product for improving application programming interface naming. An alternate name is received for a target application programming interface feature from a consumer developer. In addition, an indirection to the application programming interface feature is generated based on the alternate name. Then, the indirection to the application programming interface feature is transmitted to an indirections repository.05-17-2012
20120222019Control Flow Graph Operating System Configuration - 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.08-30-2012
20120167064ALGORITHM SELECTION DEVICE AND ALGORITHM SELECTION METHOD - Provided is a computer-readable, non-transitory medium storing an algorithm selection program for selecting one of algorithm among of a plurality of algorithms included in an extension program for executing a predetermined function when a call-out source program calls out the extension program, the algorithm selection program causing an information processing device including a storage device to execute:acquiring, from the storage device, selection information in which a command for calling out the extension program in the call-out source program and the one of algorithm are correlated; and selecting an algorithm for executing the predetermined function based on the acquired selection information.06-28-2012
20100223603MULTIPLE STAGE PROGRAM RECOMPILER USING INFORMATION FLOW DETERMINATION - A method for dynamic recompilation of source software instructions for execution by a target processor, which considers not only the specific source instructions, but also the intent and purpose of the instructions, to translate and optimize a set of equivalent code for the target processor. The dynamic recompiler determines what the source operation code is trying to accomplish and the optimum way of doing it at the target processor, in an “interpolative” and context sensitive fashion. The source instructions are processed in blocks of varying sizes by the dynamic recompiler, which considers the instructions that come before and after a current instruction to determine the most efficient approach out of several available approaches for encoding the operation code for the target processor to perform the equivalent tasks specified by the source instructions. The dynamic compiler comprises a decoding stage, an optimization stage and an encoding stage.09-02-2010
20100205586Evaluation compiler method - A method and software system allowing the ability to use an existing Excel model and extract the business intelligence, relationships, computations and model into pure mathematical relationships and codes such that the business intelligence in the original model is completely protected and the model can be run at extremely high speed and advanced simulations of hundreds of thousands to millions of trials can be run.08-12-2010
20130174133ADAPTIVE SELECTION OF PROGRAMMING LANGUAGE VERSIONS FOR COMPILATION OF SOFTWARE PROGRAMS - 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.07-04-2013
20130174132SYSTEMS AND METHODS FOR DATA BRICK CREATION AND USE - 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.07-04-2013
20120240105OSGi DYNAMIC BUNDLE GENERATION AT RUNTIME - A method of dynamically creating an OSGi bundle includes determining a directory for creation of the OSGi bundle, a runtime environment, and an OSGi framework, determining a functionality and data for the OSGi bundle based on the runtime environment and the OSGi framework, creating a JAR file of the OSGi bundle with the data and the functionality, and creating a bundle manifest for the OSGi bundle accordingly.09-20-2012
20120272223Technique for Run-Time Provision of Executable Code using Off-Device Services - A technique for obtaining executable code by a multi-core client device comprising a host core and at least one processing element implemented on a core different from the host core is provided. A method embodiment of this technique comprises the following steps performed by the host core at run-time of a host program: determining a non-executable code portion embedded in the host program; requesting executable code for a detected non-executable code portion from a remote network server; receiving the requested executable code from the network server; and providing the received executable code for execution by the processing element. The host program may conform to the OpenCL framework or any other framework that permits the embedding of non-executable code portions in an executable host program.10-25-2012
20110239199PROGRAM COMPILER, PROGRAM INSTALLER, AND PROGRAM INSTALL METHOD - A program installation apparatus may install a program in an immediately executable form using a snapshot image. The snapshot image may store a partially executed result of the program. A snapshot point at which the snapshot image is created may be decided by analyzing dependency on a system execution environment of the program. The program installation apparatus may, in advance, execute a part of the program having no dependency on the system execution environment to create a snapshot image and then execute the remaining part of the program based on the snapshot image, reducing a start-up time of the program.09-29-2011
20110276952TELECOMMUNICATIONS APPLICATION GENERATOR - An arrangement for generating a telecommunications application (such as a voicemail application) is described. The arrangement provides a graphical user interface that enables a user to select telecommunications application building blocks and to position and connect those blocks on the display in order to define an algorithm. The algorithm can be implemented using pre-defined modules for said building blocks.11-10-2011
20110276951MANAGING RUNTIME EXECUTION OF APPLICATIONS ON CLOUD COMPUTING SYSTEMS - Instances of a same application execute on different respective hosts in a cloud computing environment. Instances of a monitor application are distributed to concurrently execute with each application instance on a host in the cloud environment, which provides user access to the application instances. The monitor application may be generated from a specification, which may define properties of the application/cloud to monitor and rules based on the properties. Each rule may have one or more conditions. Each monitor instance running on a host, monitors execution of the corresponding application instance on that host by obtaining from the host information regarding values of properties on the host per the application instance. Each monitor instance may evaluate the local host information or aggregate information collected from hosts running other instances of the monitor application, to repeatedly determine whether a rule condition has been violated. On violation, a user-specified handler is triggered.11-10-2011
20110276950NAME BINDING EXTENSIBILITY FOR TYPED PROGRAMMING LANGUAGE - Architecture that provides a way to plug into a compiler (e.g., F#) and the associated language service. The language components define a standard plug-in mechanism that allows any component to plug into the services and, provide name binding and type resolution services. The compiler and language service utilize the protocol defined (e.g., in the shape of interfaces and classes that must be implemented in order to plug-in to the system) to provide compile time and design time extensions. The architecture provides the ability to define a customized protocol to interact with the compiler's name binding mechanism. The use of this protocol allows not only compilation to succeed, but to also provide rich IDE services, such as name lookup, and value lookup for quick information. Additionally, the capability to provide static type information to satisfy the requirements of a typed programming language is supported.11-10-2011
20130014092MULTI LEVEL VIRTUAL FUNCTION TABLES - A multi level virtual function table uses a hierarchy of chunks or segments of virtual function tables to identify methods for a particular class. At least one level of indirection pointers may point to individual virtual function table chunks, which may be shared by multiple classes. In some embodiments, fixed size chunks of virtual function tables may be used, other embodiments may use variable sized chunks of virtual function tables. In just in time compiled code, virtual function tables may be limited to sharing across parent and child classes, while in pre-compiled code, more complex sharing may be used.01-10-2013
20120151456LOW POWER PROGRAM COMPILING DEVICE, METHOD AND COMPUTER READABLE STORAGE MEDIUM FOR STORING THEREOF - A low power program compiling method includes the following steps: a program to be compiled is received. Wherein, the program includes several instructions to be compiled, the program is executed by an electrical device, which includes several candidate hardware units, after compiled. One of the candidate hardware units is selected as a target hardware unit. Several target hardware instructions, which access the target hardware unit, are detected from the instructions. The target hardware instructions are gathered into a hardware instruction block of the program. An enabling instruction for enabling the target hardware unit and a disabling instruction for disabling the target hardware are inserted before and after the hardware instruction block of the program respectively. The program is compiled after inserted to generate a compiled program.06-14-2012
20080235672Data layout using data type information - One embodiment relates to a computer-implemented method of compiling a software program into an executable binary file, including determining a data layout in the binary file and a data layout in the executable's dynamically allocated memory. The method includes taking into account data types of data as a factor in determining a data layout for the binary file and for the executable's dynamically allocated memory, wherein the data types include a floating-point data type and a non-floating-point data type. Other embodiments, aspects and features are also disclosed herein.09-25-2008
20130174134System and Method for Stability Guarantees in Concurrent Software - 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.07-04-2013
20080222619DETECTION OF ERRORS CAUSED BY INTERACTIONS OF INDEPENDENT SOFTWARE VENDOR CODE WITH HOST CODE - A method is provided for isolating errors which occur when code supplied by independent software vendors (ISV code) interacts with code supplied by a primary vendor (host code). Code suspected of containing ISV code with host code is executed. If the results are in error, the code is scanned and then compared with a master host code. Any differences are stored in a delta file, including locations in the host code where ISV code hooks into the host code. The code is then modified to by-pass the hooks to ISV code to generate a side-executable code and both codes are executed and the results are compared. A lack of substantial difference in the results is indicative that the ISV code adversely affects the host code while a difference between the results is indicative of an error in the modified code.09-11-2008
20120096445METHOD AND APPARATUS FOR PROVIDING PORTABILITY OF PARTIALLY ACCELERATED SIGNAL PROCESSING APPLICATIONS - A method for providing portability of partially accelerated signal processing applications may include receiving target information descriptive of accelerated function availability of a target hardware platform, receiving source code for an application and defining functions associated with the application, at least one of the functions being capable of accelerated implementation in the target hardware platform, and causing compiling of an executable code including either an at least partially hardware accelerated implementation or a processor-based implementation based on the target information. A corresponding apparatus and computer program product are also provided.04-19-2012
20130104110THERMAL-AWARE SOURCE CODE COMPILATION - Thermal-aware source code compilation including: receiving, by a compiler, an identification of a target computing system, the identification of the target computing system specifying temperature sensors that measure temperature of a memory module; compiling the source code into an executable application including inserting in the executable application computer program instructions for thermal-aware execution, the computer program instructions, when executed on the target computing system, carry out the steps of: retrieving temperature measurements of one or more of the target computing system's temperature sensors; determining, in real-time in dependence upon the temperature measurements, whether a memory module is overheated; if a memory module is overheated, entering a thermal-aware execution state including, for each memory allocation in the executable application, allocating memory on a different memory module than the overheated memory module; and upon the temperature sensors indicating the memory module is no longer overheated, exiting the thermal-aware execution state.04-25-2013
20130125100COMPUTER SYSTEM AND METHOD FOR COMPILING PROGRAM CODE AND ASSIGNING ADDRESS SPACES - A computer system is provided for compiling program code and a method for compiling program code by a processor. The method, for example, includes, but is not limited to, receiving, by the processor, the program code and compiling, by the processor, the program code, wherein the processor, when compiling the program code, parses the program code and assigns a default address space qualifier to each member functions without a defined address space qualifier and, when the member function is used, infers an address space for each default address qualifier based upon how the respective member function is being used.05-16-2013
20130125099MODULAR COMPILATION USING PARTIAL COMPILERS - A modular compiler architecture utilizes partial compiler modules that cooperatively produce object code for operation on a complex execution infrastructure. The partial compilers may invoke the services of other partial compilers, wherein each partial compiler operates as a self-contained “black-box” module. This structure, in turn, may allow the partial compilers of such implementations to be arranged in modular hierarchies for multi-level compilation and specialization of each partial compiler. These various implementations, in turn, produce compiled programs able to correctly run on large computer clusters comprising a mix of computational resources (machines, multiple cores, graphics cards, SQL server engines, etc.). Certain implementations may also be directed to compilers comprising modular partial compilers, and partial compilers may be formed from generalized forms of traditional compilers. Further disclosed is a set of high-level operations that manipulate partial compilers.05-16-2013
20100287542SINGLE CODE SET APPLICATIONS EXECUTING IN A MULTIPLE PLATFORM SYSTEM - Embodiments of the claimed subject matter are directed to methods and a system that allows an application comprising a single code set under the COBOL Programming Language to execute in multiple platforms on the same multi-platform system (such as a mainframe). In one embodiment, a single code set is pre-compiled to determine specific portions of the code set compatible with the host (or prospective) platform. Once the code set has been pre-compiled to determine compatible portions, those portions may be compiled and executed in the host platform. According to these embodiments, an application may be executed from a single code set that is compatible with multiple platforms, thereby potentially reducing the complexity of developing the application for multiple platforms.11-11-2010
20110239200METHOD FOR COMPILING A COMPUTER PROGRAM - The invention relates to a method for compiling a computer program written in a high-level programming language. In some examples, the method includes: a preliminary step of writing said program written in a high-level programming language including: a step of building a so-called PML functional basic language with reduced algebra and without re-allocation operations; a step of writing at least one library in a pre-existing language and, from said at least one library, the step of building functional interfaces from imperative functionalities be-longing to the group that includes at least: the perennial storage of information on a medium, the transmission and reception of packets on a network, and the analysis of a data flow; a step of building a high-level language by linking said interfaces in PML language functions; and a step of creating said computer program from the high-level language that includes a compilation step.09-29-2011
20100299658COMPILE-TIME CONTEXT FOR DYNAMICALLY BOUND OPERATIONS - Compile-time context information is captured and provided to a runtime binder for dynamic features in programming languages. For example, a C# run-time binder uses the information to perform a run-time bind with semantics matching the compiler's binding behavior. Dynamic programming language features supported relate to compound operations, events, delegates, member accessibility, dynamic-typed objects, structs passed by ref, arguments passed by name rather than position, extension methods, conditionally compiled methods, literal arguments, overflow checking, dynamic indexed properties, dynamic method groups, and static method groups.11-25-2010
20130159980PROCESS FOR GENERATING DYNAMIC TYPE - 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.06-20-2013
20130185703SYSTEMS AND METHODS FOR SOFTWARE INSTRUCTION TRANSLATION FROM A HIGH-LEVEL LANGUAGE TO A SPECIALIZED INSTRUCTION SET - 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.07-18-2013
20130191816OPTIMIZING TEXTURE COMMANDS FOR GRAPHICS PROCESSING UNIT - 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.07-25-2013
20110321019COMPILE-TIME MANAGEMENT OF POLYPHASIC MODULES - The disclosed embodiments provide a system that facilitates the compilation of a software program. During operation, the system uses a directory hierarchy for the software program to infer a compilation unit to be used in the software program as a member of a module. Next, the system obtains a module declaration for the module using the directory hierarchy. Finally, the system enables compilation of the software program by dynamically identifying and locating one or more dependencies of the module using the module declaration and the directory hierarchy.12-29-2011
20130198727Error Propagation - A compiler may receive source code including two user source code blocks, each capable of throwing an exception. The received source code may be associated with a policy that discards a pending exception when a subsequent exception occurs. The compiler may transform the source code such that it allows for a propagation policy that supports multiple exceptions. The transformed source code may be executed in an execution environment. Upon execution of the transformed code, a pending exception may be propagated out and a later-in-time exception may be stored.08-01-2013
20120047495EXECUTION ENVIRONMENT SUPPORT FOR REACTIVE PROGRAMMING - An execution environment is created or extended to include support for coroutines to facilitate reactive programming. Utilizing functionality provided by an execution environment, such as a virtual machine, additional operations are derived to enable creation, invocation, and suspension of coroutines.02-23-2012
20130212567GENERATING AND CACHING SOFTWARE CODE - Aspects of the subject matter described herein relate to generating and caching software code. In aspects, a target device may receive software to install. The software may include source code that has not been compiled. The target device may install the software and indicate the source code of the package is to be compiled into intermediate or executable code that is persistently stored. If the target device receives a request to execute the software prior to it being compiled, the target device may compile and execute the software without delay. If the target device receives a request to execute the software after it is compiled, the target device may obtain and execute the compiled code. The behavior above may also be applied to scripting code obtained from a server remote to the target device.08-15-2013

Patent applications in class Compiling code

Patent applications in all subclasses Compiling code