System and method of compiling a program having a mixture of host code and device code to enable Profile Guided Optimization (PGO) for device code execution. An exemplary integrated compiler can compile source code programmed to be executed by a host processor (e.g., CPU) and a co-processor (e.g., a GPU) concurrently. The compilation can generate an instrumented executable code which includes: profile instrumentation counters for the device functions; and instructions for the host processor to allocate and initialize device memory for the counters and to retrieve collected profile information from the device memory to generate instrumentation output. The output is fed back to the compiler for compiling the source code a second time to generate optimized executable code for the device functions defined in the source code.

The disclosure is related to a dynamic rebinding method for a computing unit in heterogeneous computing clouds. The method includes A dynamic rebinding method for a computing unit in heterogeneous computing clouds, receiving a first computing request from a terminal, generating a static FAT binary by compiling a device binary codes for each of all types of heterogeneous accelerators based on the first computing request, generating and storing global data including device binary codes and libraries of all types of the heterogeneous accelerators, generating a structure capable of dynamic binding by separating device binary codes for each type of the heterogeneous accelerators from the static fat binary, allocating a first compute node and first heterogeneous accelerators based on the first computing request.

A query for available plugin extensions is received from a client device. A request for operator images including plugin extensions is transmitted to a repository including multiple operator images, wherein each of the operator images includes corresponding metadata identifying the plugin extensions. Identifications of the operator images including the plugin extensions and the corresponding metadata identifying the plugin extensions are received from the repository. A listing of the plugin extensions is transmitted to the client device.

Provided is an apparatus including a communication module including a processor and a communication unit; and an application module detachably coupled to the communication module, wherein the application module includes a functional unit including at least one of a sensor, an actuator, or a communication port that is to be connected to at least one of an external sensor or an external actuator, and an application module memory for storing firmware that is executed by the processor.

A normal mode is a processing mode in which processing based on a first architecture for an information processing method is executed, and a compatible mode is a processing mode in which processing based on a second architecture for another information processing method is executed. In the normal mode, first result data obtained by executing the processing based on the first architecture is inputted to an output section configured to output inputted data to a user. In the compatible mode, second result data obtained by executing the processing based on the second architecture is inputted to the output section, in a manner adapting the second result data to input of the output section.

Embodiments of the present invention provide a method, computer program product, and system for debugging optimized code. The system includes a FAT binary, wherein the FAT binary comprises a non-optimized native code and an internal representation of a program's source code. An optimus program is configured to transform the internal representation of the program's source code into a fully optimized native code. The system also includes an enhanced loader, wherein the enhanced loader is configured to communicate with a debugger to determine a type of code to load.

A device selectively executes native machine code of a computing method in an application. Prior to execution of the application, a predicted usage level of the computing method is determined based on available statistical analysis data of the computing method. According to a determination of whether the predicted usage level exceeds a threshold, a selector selects executable code of the computing method for execution. The executable code is the native machine code or bytecode of the computing method. When the computing method is called during execution of the application, the selected executable code is loaded from non-volatile storage into memory for execution by a virtual machine. Furthermore, runtime usage level of the computing method is monitored to determine whether to switch from bytecode to native machine code execution.

Computing systems, for example, multi-tenant systems deploy software artifacts in data centers created in a cloud platform using a cloud platform infrastructure language that is cloud platform independent. The system receives pipeline templates including templating expressions that can be substituted with values for generating pipelines. A pipeline can be executed to perform a set of actions associated with continuous delivery of a software artifact. The system stores sets of partially hydrated pipeline templates. The partially hydrated pipeline templates can be compiled into executable pipelines associated with services configured on a datacenter of a cloud platform. The system stores different versions of pipeline templates as deployment packages. The system stores version pointers that identify specific deployment packages that are selected when a software release is deployed. The version pointers allow the deployment package to be updated in case of roll back or for deploying more recent changes.

Embodiments described herein provide for system and methods to enable an operating environment that supports multi-OS applications. One embodiment provides for a non-transitory machine-readable medium storing instructions that cause a data processing system to perform operations to detect conflicts during a build process for a dynamic library. The operations include loading program code for the dynamic library to build for a first platform, parsing the set of interfaces and data structures exported by the dynamic library to verify consistency of a build contract for the dynamic library, and generating a build error during a build process for the dynamic library upon detecting an inconsistent build contract specifying at least an application binary interface (ABI) and an API for the dynamic library.

A function is compiled against a first application binary interface (ABI) and a second ABI of a native first instruction set architecture (ISA). The second ABI defines context data not exceeding a size expected by a third ABI of a foreign second ISA, and uses a subset of registers of the first ISA that are mapped to registers of the second ISA. Use of the subset of registers by the second ABI results in some functions being foldable when compiled using both the first and second ABIs. First and second compiled versions of the function are identified as foldable, or not, based on whether the compiled versions match. Both the first and second compiled versions are emitted into a binary file when they are not foldable, and only one of the first or second compiled versions is emitted into the binary file when they are foldable.