Abstract: An apparatus and method for initializing system global variables by using a multiple load/store instruction is disclosed. The apparatus includes: a first storing unit for storing a system global variable initialization function and initialization functions using multiple load/store instruction; a second storing unit for storing a return address; a control unit for storing a first return address to the second storing unit when the system global variable initialization function is called for initializing the system global variable, initializing the system global variables by calling the initialization functions using multiple load/store instruction while performing the system global variable function and performing a rest of system global variable initialization function by finding and executing an execution sequence based on the first return address stored in the second storing unit; and a third storing unit for storing the system global variables initialized according to the control unit.

Abstract: A device initiates a technical computing environment (TCE), and receives, via the TCE, a program command that permits the TCE to access a graphical processing unit that is remote to the device, where the program command permits the TCE to seamlessly transfer data to the remote GPU. The device transforms, via the TCE, the program command into a program command that is executable by the remote GPU, and provides the transformed program command to the remote GPU for execution. The device also receives, from the remote GPU, one or more results associated with execution of the transformed program command by the remote GPU, and utilizes the one or more results via the TCE.

Abstract: Systems and methods for the vectorization of software applications are described. In some embodiments, source code dependencies can be expressed in ways that can extend a compiler's ability to vectorize otherwise scalar functions. For example, when compiling a called function, a compiler may identify dependencies of the called function on variables other than parameters passed to the called function. The compiler may record these dependencies, e.g., in a dependency file. Later, when compiling a calling function that calls the called function, the same (or another) compiler may reference the previously-identified dependencies and use them to determine whether and how to vectorize the calling function. In particular, these techniques may facilitate the vectorization of non-leaf loops. Because non-leaf loops are relatively common, the techniques described herein can increase the amount of vectorization that can be applied to many applications.

Abstract: Methods for simulating an instruction set architecture (ISA) with a instruction set simulator (ISS) are provided. One exemplary embodiment of the methods includes fetching a first decoded instruction during a run time, where the decoded instruction is decoded from an original instruction in a target application program during a compile time preceding the run time. The decoded instruction can designate a template configured to implement the functionality of the original instruction. The method also preferably includes determining whether the fetched instruction is modified from the original instruction and then executing the designated template if the instruction was not modified. The method can also include decoding the original instruction during the compile time by selecting a template corresponding to the original instruction and then customizing the template based on the data in original instruction. The method can also include optimizing the customized template during the compile time.

Abstract: Compiling source code to provide an executable code build. The method includes configuring a pool of substantially identical virtual machines in a distributed cloud computing environment. Configuring may include configuring virtual machines to have generic code compiling functionality. The method further includes determining that source code for a particular user should be compiled. As a result, the method includes selecting a virtual machine from the pool of substantially identical virtual machines and configuring the selected virtual machine in a way that is specific to the user. Source code for the user is retrieved from a source control system deployed in the distributed computing environment. Using the virtual machine configured in the way specific to the user, the user's retrieved source code is compiled to compiled code. After compiling is completed, the configured virtual machine is restored to a generic form.

Abstract: Compiling code for an enhanced application binary interface (ABI) including identifying, by a computer, a code sequence configured to perform a variable address reference table function including an access to a variable at an offset outside of a location in a variable address reference table. The code sequence includes an internal representation (IR) of a first instruction and an IR of a second instruction. The second instruction is dependent on the first instruction. A scheduler cost function associated with at least one of the IR of the first instruction and the IR of the second instruction is modified. The modifying includes generating a modified scheduler cost function that is configured to place the first instruction next to the second instruction. An object file is generated responsive to the modified scheduler cost function. The object file includes the first instruction placed next to the second instruction. The object file is emitted.

Abstract: A method and an apparatus that optimally compile a source code for a data transformation operation in response to a request from a run-time application are described. A current state of the run-time application is included in the request. The application executes a non-optimized library routine for the data transformation operation while a separate worker thread performs optimized code compilation on the source code for the data transformation operation based on the request at the same time. The request includes a current state of the run-time application. The non-optimized library routine has been pre-built during build time.

Abstract: A computer implemented method includes receiving a client programming language input and a server programming language input, processing the client and server programming language inputs, and translating the client programming language input into an executable client application and the server programming language input into an executable server application, the executable client and server applications operable to communicate with each other. Processing the client and server programming language inputs includes identifying any invocations of server procedures of the server programming language input in the client programming language input, producing a combined server procedure in the server programming language input for identified server procedures invoked by the client programming language input, and replacing invocations of the identified server procedures in the client programming language input with an invocation of the combined server procedure.

Abstract: 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.

Abstract: Platform-agnostic source code can be augmented with one or more portions of source code annotated for different platforms and/or versions. The source code including both the platform-agnostic and platform-specific and/or version-specific portions can be compiled once to create a single executable that can be distributed to and can run on multiple device platforms and/or multiple versions of one or more platforms. Platform-specific or version-specific executables (e.g., assemblies, binaries, etc.) can be embedded into a binary or executable as resources (e.g., data). When the compiled code is executed on a device, the runtime can extract the platform-specific portion corresponding to the device on which the executable is being run, can bind the extracted portion to the executable and can load and execute the executable. Hence the same binary can produce different results or functionalities depending on the capabilities of the platform on which the binary runs.

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

Abstract: Provided is an XML processing device capable of describing, using conventional XML processing language, a method of processing also an asynchronously inputted XML. The XML processing device converts, according to a predetermined rule, the XML inputted asynchronously from outside and outputs the XML. The XML processing device is characterized by including an XML conversion module which performs XML conversion of the XML inputted according to the rule, an output destination interpretation module which interprets an output destination described in the converted XML, and an output distribution module which allows the XML to be outputted to the output destination interpreted by the output destination interpretation module.

Abstract: 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.

Abstract: A method of determining which computer program functions are changed by a source code modification to a computer program's source code. The method includes compiling the computer program's source code, using a compiler that generates a relocation entry for each program access to a program function or a program data item. The method further includes compiling source code resulting from modifying the computer program's source code with the source code modification, using a compiler that generates a relocation entry for each program access to a program function or a program data item The method further includes constructing a list of object code differences by comparing the compiled source code, and excluding from the list specified object code differences.

Abstract: Systems and methods of code evaluation for in-order processing are disclosed. In an embodiment, the method includes identifying a first instruction having multiple execution source paths. The method also includes generating a first execution path model identifying an execution order of multiple instructions based on a first condition and generating a second execution path model identifying an execution order of a second instruction based on a second condition. The method includes evaluating at least one of the execution path models to identify a hazard condition.

Abstract: Embodiments of the present invention provide an architecture for securely and efficiently executing byte code generated from a general programming language. In particular, a computer system is divided into a hierarchy comprising multiple types of virtual machines. A thin layer of software, known as a virtual machine monitor, virtualizes the hardware of the computer system and emulates the hardware of the computer system to form a first type of virtual machine. This first type of virtual machine implements a virtual operating domain that allows running its own operating system. Within a virtual operating domain, a byte code interpreter may further implement a second type of virtual machine that executes byte code generated from a program written in a general purpose programming language. The byte code interpreter is incorporated into the operating system running in the virtual operating domain.

Abstract: A dynamic compiling method, and device for sequentially compiling a partial computer program in a computer. The computer runs methods to acquire respective values of one or more pieces of current execution status information; read, from the shared pool, a list of the conditions associated with an executable instruction stream generated by compiling a partial program that is the same as a partial program to be compiled, and determine whether respective values of corresponding pieces of current execution status information satisfy the conditions. The computer runs methods to further generate an executable instruction stream by compiling the partial program to be compiled on the condition that a result of determination made is negative.

Abstract: An object code hot update system generates hot updates for patching running programs by analyzing upstream post-patch code, augmenting the upstream post-patch code to provide augmented post-patch code with additional initialization functionality. The system further provides techniques to identify a candidate extra-change site in upstream post-patch code and modify the upstream post-patch code to generate a hot update.

Abstract: Techniques are described herein that are capable of instantiating and executing in-process wrapped execution engine(s) for tooling a dynamic program across a process boundary. For instance, a dynamic language execution engine may be instantiated in a wrapper object that is hosted in a host process to provide a wrapped execution engine while the host process is running. The wrapped execution engine may be configured to provide information regarding execution of a targeted application of the host process to a requesting application. The wrapped execution engine may be isolated from other execution engine(s) that are included in the host process such that the targeted application does not have access to code that defines the wrapped execution engine. The targeted application may include one or more of the other execution engines.

Abstract: Various technologies and techniques are disclosed that provide software transactional protection of managed pointers. A software transactional memory system interacts with and/or includes a compiler. At compile time, the compiler determines that there are one or more reference arguments in one or more code segments being compiled whose source cannot be recovered. The compiler executes a procedure to select one or more appropriate techniques or combinations thereof for communicating the sources of the referenced variables to the called code segments to ensure the referenced variables can be recovered when needed. Some examples of these techniques include a fattened by-ref technique, a static fattening technique, a dynamic ByRefInfo type technique, and others. One or more combinations of these techniques can be used as appropriate.

Abstract: One set of instructions is generated in part by compiling application-specific source code. When natively executed on a platform provided by a device, the set of instructions provides an application. Another set of instructions is generated in part by compiling the same business logic source code. When natively executed on another platform provided by another device, the other set of instructions provides the same application. The business logic source code is substantially free of code specific to any platform. Moreover, the business logic source code defines substantially all application-specific functionality of the application.

Abstract: A system that translates source code of a compiled high level language into bytecode. Compiled languages are so named because their implementations are typically compilers that generate machine code. The described system takes source code of the compiled high level language and translates it into bytecode. The bytecode can be optimized with control flow analysis and method splitting.

Abstract: A system, method, and computer program product are provided for determining whether code is unwanted based on the decompilation thereof. In use, code is identified and the code is decompiled. In addition, it is determined whether the code is unwanted, based on the decompiled code.

Abstract: Receiving assembly language source code for a computer program and identifying within the assembly language source code a conjoined directive that conjoins a load instruction and an assembler directive. The conjoined directive can identify a data structure, a first register, and a second register that contains an address of a location in memory that contains the data structure. Via a processor, the conjoined directive can be processed to create object code that includes operation code that loads into the first register the address of the location in memory that contains the data structure. The object code can be output.

Abstract: Methods and apparatuses associated with vectorization of scalar callee functions are disclosed herein. In various embodiments, compiling a first program may include generating one or more vectorized versions of a scalar callee function of the first program, based at least in part on vectorization annotations of the first program. Additionally, compiling may include generating one or more vectorized function signatures respectively associated with the one or more vectorized versions of the scalar callee function. The one or more vectorized function signatures may enable an appropriate vectorized version of the scalar callee function to be matched and invoked for a generic call from a caller function of a second program to a vectorized version of the scalar callee function.

Abstract: External references are resolved in a software compiling and linking environment by identifying a group of related external references and by processing the group of external references until a stopping condition is satisfied. The external references are processed by selecting a next external reference from the group of external references as a current external reference and by resolving the current external reference with a matching definition if a matching definition for the current external reference exists. The stopping condition is designated as being satisfied if either the selected external reference is resolved, or if each external reference in the group of external references has been selected.

Abstract: External references are resolved in a software compiling and linking environment by identifying a group of related external references and by processing the group of external references until a stopping condition is satisfied. The external references are processed by selecting a next external reference from the group of external references as a current external reference and by resolving the current external reference with a matching definition if a matching definition for the current external reference exists. The stopping condition is designated as being satisfied if either the selected external reference is resolved, or if each external reference in the group of external references has been selected.

Abstract: A solution for identifying a software developer based on debugging information includes an identification module configured to identify a developer of a line of source code, a determination module configured to determine a developer contact tag for the developer, an encoding module configured to encode the developer contact tag, a tagging module configured to automatically tag the line of source code with the developer contact tag associated with the developer. The solution also includes a debug module configured to provide debug information, a decoding module configured to decrypt the developer contact tag, and a presentation module configured to present the debug stack trace in human readable form.

Abstract: Apparatus and methods are provided for controlling the loading status of DLLs. Specifically, a streaming program compiler is provided. The compiler includes operation modules for calling DLLs during streaming program execution; association table generating units for generating association tables according to user-defined rules, where the association table includes entries indicating (i) stream branches of the streaming program and (ii) an operation module corresponding to the stream branches; and a trigger generating unit for generating a trigger based on user-defined rules, where the trigger generating unit (i) determines which conditions for loading and unloading DLLs fit the streaming program, (ii) matches these conditions to a particular stream branch to identify a matched stream branch, and (iii) sends out triggering signals indicating the matched stream branch. This invention also provides a corresponding method and controller.

Abstract: An approach is provided to receive a request at a first computer system from a second system. The first system generates an encryption key, modifies retrieved source code by inserting the generated encryption key into the source code, and compiles the modified source code into an executable. A hash value of the executable program is calculated and is stored along with the encryption key in a memory area. The executable and the hash value are sent to the second system over a network. The executable is executed and it generates an encrypted result using the hash value and the embedded encryption key. The encrypted result is sent back to the first system where it is authenticated using the stored encryption key and hash value.

Abstract: Testing of a computer program product by selecting a test node at which a snapshot is to be acquired to enable the completion of tests along test scenarios in the shortest time is provided. Information on a test scenario, information on a test node to which a test node makes a next transition, and other information are stored. For each test node, it is determined whether a branch path exists, and for each of these test nodes, an estimated execution time required to complete a test when a snapshot is acquired at a test node is calculated, an execution time required to complete a test without acquiring any snapshot is calculated, and a difference between the execution time and the estimated execution time is calculated as a reduced time. A test node with the longest reduced time is selected, and information for identifying the selected test node is output.

Abstract: Systems, servers, methods, and media for interfacing first compiled code of first code with second compiled code of second code are provided. The first compiled code includes a first compiled object that corresponds to an original object in the first code, and includes a first API wrapper that associates the first compiled object with the original object. The second compiled code includes a second compiled object that corresponds to a reference in the second code to the original object, and includes a second API wrapper that associates the second compiled object with the reference. When the second compiled object in the second compiled code is executed, the second compiled code calls the second API wrapper, the second API wrapper proxies the call to the first API wrapper, and the first API wrapper proxies the call to the first compiled object in the first compiled code.

Abstract: A method, capable of being implemented in executable instructions or programmes in device(s), including computer system(s) or computer-controlled device(s) or operating-system-controlled device(s) or system(s) that is/are capable of running executable code, providing for the creation in Device(s) of executable code, such as boot code, programmes, applications, device drivers, or a collection of such executables constituting an operating system, in the form of executable code embedded or stored into hardware, such as embedded or stored in all types of storage medium, including read-only or rewriteable or volatile or non-volatile storage medium, such as in the form of virtual disk in physical memory or internal Dynamic Random Access Memory or hard disk or solid state flash disk or Read Only Memory, or read only or rewriteable CD/DVD/HD-DVD/Blu-Ray DVD or hardware chip or chipset etc.

Abstract: Aspects of the subject matter described herein relate to creating and using deltas to modify existing computer code. In aspects, computer code may be translated into a higher level language to make it easier for a software developer to modify the computer code. The translated computer code may be presented by an editing tool that presents a user interface that allows changes to be made to the translated computer code. A delta engine may then determine a delta that indicates the changes to perform on the existing computer code to create computer code that would result from compiling the translated computer code as changed via the editing tool. Later, this delta may be used to change the existing computer code after it has been loaded to add or change debugging hooks or other features of the computer code.

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

Abstract: 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.

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

Abstract: A system includes a source database storing a targeted source code having references to hard-coded configuration information. A converter is in communication with the source database and is configured to replace the hard-coded configuration information in the targeted source code with soft-coded configuration information. A method includes searching the targeted source code for references related to hard-coded configuration information, receiving new reference names for the references, each of the new reference names corresponding to at least one of the references and being related to soft-coded configuration information, and replacing the references related to hard-coded configuration information with the corresponding new reference name to generate a targetless source code with the soft-coded configuration information.

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

Abstract: The present invention extends to methods, systems, and computer program products for representing various programming elements with compiler-generated tasks. Embodiments of the invention enable access to the future state of a method through a handle to a single and composable task object. For example, an asynchronous method is rewritten to generate and return a handle to an instance of a builder object, which represents one or more future states of the asynchronous method. Information about operation of the asynchronous method is then passed through the handle. Accordingly, state of the asynchronous method is trackable prior to and after completing.

Abstract: A provisioning server can maintain a library of virtual images. The virtual images can be a disk image of software that has been previously installed according to metadata. The metadata can represent parameters utilized to create the virtual image and the parameters required to provision the virtual image on a target machine. The provisioning server can maintain the metadata for a virtual image in a virtual image record associated with the virtual image. The provisioning server can provision a virtual image to one or more target machines. To provision the virtual image, the provisioning server can copy the virtual image to a storage device on the one or more target machines and configure the target machine according to metadata in the associated virtual image record.

Abstract: 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.

Abstract: The present invention relates to a content protection apparatus and method using binding of additional information to an encryption key. The content protection apparatus includes an encryption unit for creating an encryption key required to encrypt data requested by a user terminal and then generating encrypted data in which the data is encrypted. An additional information management unit manages additional information including authority information about the encrypted data. A White-Box Cryptography (WBC) processing unit generates a WBC table required to bind the encryption key corresponding to the encrypted data to the additional information. A bound data generation unit generates bound data in which the encrypted key is bound to the additional information, using a cipher included in the WBC table.

Abstract: One embodiment of the present invention sets forth a technique for translating application programs written using a parallel programming model for execution on multi-core graphics processing unit (GPU) for execution by general purpose central processing unit (CPU). Portions of the application program that rely on specific features of the multi-core GPU are converted by a translator for execution by a general purpose CPU. The application program is partitioned into regions of synchronization independent instructions. The instructions are classified as convergent or divergent and divergent memory references that are shared between regions are replicated. Thread loops are inserted to ensure correct sharing of memory between various threads during execution by the general purpose CPU.

Abstract: A system and method for improving modularity of a software source code is provided. The system comprises of a user interface for receiving source code; a source code model extractor for parsing and forming a model of the source code; a source code model database for storing the source code model, refactoring operators, and a record of refactoring changes; a modularity improvement analyzer for reading the source code model and modularity problem diagnosis data and generating a set of prescriptions; an optimal improvement suggestion selector for evaluating and selecting prescriptions; and a refactoring engine for receiving selected prescriptions and applying them on the source code.

Abstract: A method, system and computer program product for performance configuration of an application by setting at least one performance preference for a performance-sensitive class in the application, specifying performance preference propagation policy of the class in the application based on the at least one performance preference, and calling the class to perform performance configuration for application according to the performance preference propagation policy.

Abstract: Methods, systems, apparatus, and computer-readable media for validating components of a dynamic user interface in an on-demand multi-tenant service environment are disclosed. Organizations corresponding to tenants in the on-demand multi-tenant service environment are identified. A multi-tenant database system residing on multiple servers is provided for each of the identified organizations. Dynamic user interface pages associated with the organizations are identified. First and second compilation outputs based upon respective first and second invocations of a compiler configured to compile the one or more dynamic user interface pages are produced with reference to respective first and second builds of computer program code. Differences between the first and second compilation outputs are identified and presented in a user interface on a display device of the multi-tenant service environment.

Abstract: 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.

Abstract: Compiling source code for debugging, including: receiving, by an optimizing compiler from a debugger, a user specification of preferred breakpoint locations in the source code; compiling, by the optimizing compiler, the source code, wherein compiling includes inserting a snapshot at one or more of the preferred breakpoint locations, and recording the location of each inserted snapshot; and providing, to the debugger by the optimizing compiler, the recorded locations of each inserted snapshot along with the compiled source code.

Abstract: A software compiler is provided that is operable for generating an executable that comprises instructions for a plurality of different instruction sets as may be employed by different processors in a multi-processor system. The compiler may generate an executable that includes a first portion of instructions to be processed by a first instruction set (such as a first instruction set of a first processor in a multi-processor system) and a second portion of instructions to be processed by a second instruction set (such as a second instruction set of a second processor in a multi-processor system). Such executable may be generated for execution on a multi-processor system that comprises at least one host processor, which may comprise a fixed instruction set, such as the well-known x86 instruction set, and at least one co-processor, which comprises dynamically reconfigurable logic that enables the co-processor's instruction set to be dynamically reconfigured.