Abstract: The invention provides for a method of encrypting and executing an executable image, comprising; flagging sections of the executable image to be encrypted using commands in source files and compiling said executable images so as to generate object files, linking one or more of said executable images using a linker to produce a final executable image, passing said linked executable images to a post-linker encryption engine to encrypt a relocation fix-up patch table and sections of executable images flagged for encryption, and at load time decrypting relocating and executing the executable images.

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: An integrated circuit includes a plurality of tiles. Each tile includes a processor, a switch including switching circuitry to forward data over data paths from other tiles to the processor and to switches of other tiles, and a switch memory that stores instruction streams that are able to operate independently for respective output ports of the switch.

Abstract: The embodiments described herein generally relate to methods and systems for enabling a client to request a server to cancel the digital signing of a form file associated with a form. Successful cancellation of the digital signing process results in a return of the form file to its initial state, in which data are not lost, and the form can be resubmitted and/or the application of the digital signature can be retried. Request and response messages, communicated between a protocol client and a protocol server, cause the performance of protocol functions for applying a digital signature to a form file and for cancelling the signature thereof where errors in the signing process are detected. A versioning mechanism enabling the detection of version differences and resulting upgrades to the digital signature control allows for robust communications between a client and a server operating under different product versions.

Abstract: Described is a technology in a programming (development and/or runtime) environment by which data type mismatches between the output and input of computer program software components (e.g., APIs) are detected, with the output transparently converted such that the converted input may be understood by the inputting component. When components are interconnected in a programming environment, metadata associated with those components is evaluated to determine a type mismatch, e.g., between objects and arrays. If mismatched, an output object is converted to a single-element array for input, or alternatively, an output array is converted to a series of objects, each object sent within a loop for input. The transparent conversion may be performed by the programming environment during runtime, or by inserting conversion code prior to compilation.

Abstract: A project system is automatically configured from project capabilities determined from an instance of a build system by a project capabilities analyzer. A flexible configuration based build system defines the consuming project system. Results of an evaluated project file are used to define the overall capabilities of the build system. The capabilities are used to dynamically load and assemble the project system code. Changes in the project capabilities due to a reevaluation of a result of a build can then redefine and reassemble the project system code. Hence project system configuration is data-driven rather than user-defined and utilizes a flexible, configuration based build system to define the consuming project system.

Abstract: An example method includes obtaining annotated source code and based at least in part on a first annotation, separating the source code into first and second source code portions. The method also includes generating from the first source code portion a first source code stream to be supplied for compilation by a first compiler, the first source code stream augmented, based on the first annotation, to include additional coordination code not present in the obtained source code, and the first compiler specific to the first-type subset of the target CPUs. The method further includes generating from the second source code portion a second source code stream to be supplied for compilation by a second compiler, the second compiler specific to a second-type subset of the target CPUs. The target CPUs of the first- and second-type subsets have one or more different functionalities.

Abstract: The disclosed system provides a transformation-based implementation of forward-mode and reverse-mode automatic differentiation as a built-in, first-class function in a functional programming language. Each of these constructs imposes only a small constant factor of the computational burden (time) of the function itself, and the forward construct has the same properties in terms of space. The functions can be applied to any function, including those involving derivatives and nested closures.

Abstract: In a method for managing software menus using a computing device, a template file from a storage system is loaded. A name of an array, names of a plurality of software menus of the array, names of a plurality of buttons of the software menus and separators between the buttons, and parameters comprising an identifier (ID) and an image path of each of the buttons are obtained by parsing each line of instructions in the template file. A toolbar container for storing the obtained data having a predetermined memory frame is created. The software menus are established at a predetermined location in a preset window and the buttons of each of the software menus are added for each of the established software menus by reading data in the toolbar container. The window with the established software menus is displayed on a display screen.

Abstract: A method, a system and computer program product for resolving conflicts in applications are disclosed, A first set of instructions configured to use a second set of instructions is identified during execution of a program having the first set of instructions. A third set of instructions couples the first set of instructions to the second set of instructions. I Incompatibility between the first set of instructions and the second set of instructions is identified, in response to compiling the first set of instructions and compiling the second set of instructions. A mechanism is provided for the third set of instructions to modify the second set of instructions, which result in a modified second set of instructions compatible with the first set of instructions.

Abstract: A method, a system and computer program product for resolving conflicts in applications are disclosed, A first set of instructions configured to use a second set of instructions is identified during execution of a program having the first set of instructions. A third set of instructions couples the first set of instructions to the second set of instructions. I Incompatibility between the first set of instructions and the second set of instructions is identified, in response to compiling the first set of instructions and compiling the second set of instructions. A mechanism is provided for the third set of instructions to modify the second set of instructions, which result in a modified second set of instructions compatible with the first set of instructions.

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

Abstract: A priority selection mechanism for driving outputs from control logic which can be automatically translated to controllers of various protocols. The priority selection mechanism may assign a priority to the outputs and select the output having the highest priority as the output of the control logic. There may be an abstract representation of the priority logic which may permit a protocol mechanism to be used in the logic without the designer or user needing to know the details of the mechanism.

Abstract: A method is described for preserving the flexibility associated with relative memory addressing in programs designed to be stored in read-only memory.

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

Abstract: A debug tool that generates a call stack listing by analyzing the crash memory dump data without relying on register data values. The tool uses information gathered by the compiler and linker when the program was compiled and linked, including the stack's size and location in memory. By examining the stack location in the crash memory dump image in conjunction with the debugging data generated by the compiler and the linker and any existing trace data, the last valid frame may be reconstructed indicating the location of the crash.

Abstract: A target program is instrumented during execution by using statements in high-level programming languages, without restarting the target and without modifying the compiled binary of the target on disk. The target and the analysis program modifying it may each include managed code. The target program is presented by an instrumentation API as a queryable database, rather than a mere sequence of processor-level instructions. An instrumentation context for the target program's execution image is obtained, with identifications of functions, individual instructions, and other instrumentable items that satisfy criteria specified in a query. Functions and low-level instructions may be identified as satisfying the query regardless of whether they have executed yet. High-level statements transform query-satisfying items in the target's execution image, by appending code, injecting a fault, replacing an individual instruction, or replacing an individual operand.

Abstract: The system and methods described herein may be used to detect and tolerate atomicity violations between concurrent code blocks and/or to generate code that is executable to detect and tolerate such violations. A compiler may transform program code in which the potential for atomicity violations exists into alternate code that tolerates these potential violations. For example, the compiler may inflate critical sections, transform non-critical sections into critical sections, or coalesce multiple critical sections into a single critical section. The techniques described herein may utilize an auxiliary lock state for locks on critical sections to enable detection of atomicity violations in program code by enabling the system to distinguish between program points at which lock acquisition and release operations appeared in the original program, and the points at which these operations actually occur when executing the transformed program code.

Abstract: Methods and apparatus for target typing of overloaded method and constructor arguments are described. A method comprises determining whether source code of a program includes, as an argument to an overloaded operation invocation, an expression whose type is context-dependent. The method further comprises, if the source code includes such an argument, providing the expression as an input to an overload resolver, and determining at the overload resolver whether (a) each argument of the invocation is compatible with types of corresponding parameters in one or more declarations and (b) whether a particular declaration among such a set of declarations can be identified as the most specific. If both conditions are met, the method comprises generating executable instructions for the invocation.

Abstract: Executable code may be recompiled so that generic portions of code may be replaced with specific portions of code. The recompilation may customize executable code for a specific use or configuration, making the code lightweight and executing faster. The replacement mechanism may replace variable names with fixed values, replace conditional branches with only those branches which are known to be executed, and may eliminate executable code portions that are not executed. The replacement mechanism may comprise identifying known values defined in the executable code for variables, and replacing those variables with the constant value. Once the constants are substituted, the code may be analyzed to identify branches that may be evaluated using the constant values. Those branches may be reformed using the constant value and the rest of the conditional code that may not be accessed may be removed.

Abstract: A plurality of domain-specific service adaptation languages can be supported by a back-end service adaptation system to provide runtime access to a runtime instance of a data object comprising data stored in a repository. By defining a language-specific data access service and parser for each domain-specific service adaptation language, a single, service adaptation language-independent compiler and interpreter can prepare and execute a runtime load that includes an execution plan for retrieving and converting data from the repository for delivery in a data object according to a query request from a consumer runtime environment. A consumer using the consumer runtime environment can define the service adaptation language to be used and provide a parser and source code to enable access to business object data using the back-end service adaptation system.

Abstract: Programming of modules which can be reprogrammed during operation is described. Partitioning of code sequences is also described.

Abstract: Embodiments of the invention provide systems and methods for automatically parallelizing loops with non-speculative pipelined execution of chunks of iterations with pre-computation of selected values. Non-DOALL loops are identified and divided the loops into chunks. The chunks are assigned to separate logical threads, which may be further assigned to hardware threads. As a thread performs its runtime computations, subsequent threads attempt to pre-compute their respective chunks of the loop. These pre-computations may result in a set of assumed initial values and pre-computed final variable values associated with each chunk. As subsequent pre-computed chunks are reached at runtime, those assumed initial values can be verified to determine whether to proceed with runtime computation of the chunk or to avoid runtime execution and instead use the pre-computed final variable values.

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

Abstract: The object file format and linker are enhanced to provide file attributes to allow flexible selection and placement of objects.

Abstract: According to one embodiment of the present invention, a computer system is provided where the computer system includes a main processor, first and second active memory device. The computer system is configured to perform a method including receiving an executable module generated by a compiler, wherein the executable module includes a code section identified as executable by a first processing element in the first active memory device and a second processing element in the second active memory device. The method includes copying the code section to memory in the first device based on the code section being executable on the first device, copying the code section from the first active memory device to an instruction buffer of the first processing element and copying the code section from the first device to the second device based on the code section being executable on the second device.

Abstract: According to one embodiment of the present invention, a method for operation of a computer system including a main processor, a first and a second active memory device includes receiving an executable module generated by a compiler, wherein the executable module includes a code section identified as executable by a first processing element in the first active memory device and a second processing element in the second active memory device. The method further includes copying the code section to memory in the first device based on the code section being executable on the first device, copying the code section from the memory in the first active memory device to an instruction buffer of the first processing element and copying the code section from the memory in the first device to the second device based on the code section being executable on the second device.

Abstract: An embodiment is directed to determining, by a compiler, that a call to a named barrier is matched across all of a plurality of threads, and based at least in part on determining that the call to the named barrier is matched across all of the plurality of threads, replacing, by the compiler, the named barrier with an unnamed barrier.

Abstract: A parallelism policy object provides a control parallelism interface whose implementation evaluates parallelism conditions that are left unspecified in the interface. User-defined and other parallelism policy procedures can make recommendations to a worker program for transitioning between sequential program execution and parallel execution. Parallelizing assistance values obtained at runtime can be used in the parallelism conditions on which the recommendations are based. A consistent parallelization policy can be employed across a range of parallel constructs, and inside recursive procedures.

Abstract: A computer system may comprise a computer platform and input-output devices. The computer platform may include a plurality of heterogeneous processors comprising a central processing unit (CPU) and a graphics processing unit) GPU, for example. The GPU may be coupled to a GPU compiler and a GPU linker/loader and the CPU may be coupled to a CPU compiler and a CPU linker/loader. The user may create a shared object in an object oriented language and the shared object may include virtual functions. The shared object may be fine grain partitioned between the heterogeneous processors. The GPU compiler may allocate the shared object to the CPU and may create a first and a second enabling path to allow the GPU to invoke virtual functions of the shared object. Thus, the shared object that may include virtual functions may be shared seamlessly between the CPU and the GPU.

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

Abstract: A preparsers tool is provided for converting Software Communications Architecture (SCA) Extensible Markup Language (XML) files into Common Object Request Broker Architect (CORBA) structures usable by a Software Communications Architect (SCA) Core Framework (CF). The preparsers tool retrieves a set of target environment implementation definitions (TEID) that define at least one characteristic of a target environment to which a CORBA Common Data Representation (CDR) file is provided. For each component in the target environment, one or more dependencies are merged into an implementation device dependencies list that comprises visible device dependencies and external device dependencies. The parsed set of XML files is converted into a CORBA structure type, the conversion based at least in part on the TEID, such that the conversion of the parsed set of XML files results in a CORBA structure having a type and precedence order that is correct for the target environment.

Abstract: In accordance with various embodiments, systems and methods are provided which facilitate inferring immutability of variables. A compiler analyzes local variables within source code to determine whether they are immutable. In particular embodiments the compiler examines locations where each variable is assigned to determine whether the variable was definitely unassigned before the assignment. Because the compiler can infer whether a local variable is immutable, it is possible for the programmer to avoid using a keyword to expressly declare the local variable as immutable. Inferring immutability of variables, thus, maintains correctness of the compiled code while reducing the burden on the programmer.

Abstract: Provided are a tool for supporting open computing language (OpenCL) application software development for an embedded system and a supporting method thereof. The tool in conjunction with a target system includes a project management unit configured to separate and store OpenCL application software constituted of a host program and a kernel program into a host source code corresponding to the host program and a kernel source code corresponding to the kernel program, and manage a tool-chain corresponding to an OpenCL platform of the target system, and a builder configured to determine a compile type of the kernel source code and determine whether the kernel source code is built in response to the compile type. Accordingly, it is possible to rapidly provide a tool for supporting OpenCL application software development that can develop OpenCL application software for an embedded system.

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

Abstract: An electronic device is provided that, in an embodiment, saves a plurality of values for a variable specified by a condition after a respective plurality of encounters of a breakpoint by a program that modifies the variable. One of the plurality of values is selected based on a condition. A determination is made whether to stop execution of the program at the breakpoint based on the one of the plurality of the values. Execution of the program is stopped at the breakpoint if the determining is true. The program is allowed to continue to execute if the determining is false.

Abstract: Disclosed herein are techniques for compiling a procedure for testing a page. In some implementations, a component definition for a component instance referred to in computer programming language instructions defining a test procedure for testing a page may be received. The page may be defined by a page description implemented in a markup language. The page description may include a reference to a first portion of a component instance. Compiled wrapper code operable to simulate the presence of the component instance may be generated. The compiled wrapper code may represent the first portion of the component instance referenced in the page description. A compiled test procedure may be generated based on the computer programming language instructions. The compiled test procedure may include the compiled wrapper code. The compiled test procedure may be capable of being executed to perform the test procedure.

Abstract: A preparser tool is provided for converting Software Communications Architecture (SCA) Extensible Markup Language (XML) files into Common Object Request Broker Architecture (CORBA) structures usable by an SCA Core Framework (CF) and comprises a CF_PreParsers interface definition language (IDL) and a first preparser. The CF_IDL is configured to be in operable communication with an XML parser and with at least a first type of preparser. The first type of preparser is in operable communication with the CF_PreParsers IDL, is associated with a first type of descriptor for the CF, and is configured to call the XML parser to request parsing of a first set of first XML files, convert the first parsed set of first XML files into a first CORBA structure type, encode the first CORBA structure type into a first CORBA Common Data Representation (CDR) file; and write the first CORBA CDR file as a first octet sequence.

Abstract: Unique context-based code enhancement of the core functionality of standard source code objects is performed at any position in the code. Desired insertion/replacement position(s) input by a user trigger the generation of a unique context for an enhancement. The unique context is based on characteristics of the code in the standard source code objects, such as the statements proximate to the insertion/replacement position(s). The unique context is associated with one or more extension source code objects that, when integrated into the existing source code at the insertion/replacement position(s), will provide the enhancement. At compile-time, the unique context used to unambiguously locate the insertion/replacement position(s). The extension source code objects can include industry or customer extensions, add-ons, plug-ins, and the like.

Abstract: A system and method for executing a user agent in an electronic device. Upon each startup of the user agent, the electronic device loads binary code of a base version of the user agent into memory, and determines whether a binary patch has previously been downloaded. If the patch has been downloaded, it is applied to the base version and the updated base version is executed. The binary patch may be downloaded from a server, which compiles the binary patch on the basis of stored source code of the base version and stored source code of one or more enhancements selected by the electronic device.

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

Abstract: Systems, methods, and computer-readable media for optimizing emulated fixed-function and programmable graphics operations are provided. Data comprising fixed function and programmable states for an image or scenario to be rendered is received. The data for the image is translated into operations. One or more optimizations are applied to the operations. The optimized operations are implemented to render the scenario.

Abstract: An approach is provided in which a set of common instructions are each executed by at least two processor cores. Each of the processor cores queues values resulting from at least one of the common instructions (a critical section). The queued values are compared by a queued comparator. An exception is issued in response to the comparison revealing unequal values having been queued by the processor cores.

Abstract: A computing device programmed with an extensible framework that accepts one or more mark-up language parsers and/or generators, each implemented as plug-ins to the framework, with different plug-ins enabling different kinds of mark up languages to be handled by the device. In this way, the client is no longer tied to a single kind of parser or generator; it can operate with any different kind of parser compatible with the intermediary layer, yet it remains far simpler that prior art clients that are hard-coded to operate directly with several different kinds of parsers and generators.

Abstract: A first compiler generates one or more object codes from a program code for a first processor included in an arithmetic processing system to which a plurality of processors are mutually connected. A first linker links the generated one or more object codes to generate an execution file for the first processor. A parameter information generation unit generates, based on the information acquired from the first linker, parameter information used in a second processor included in the arithmetic processing system. A second compiler refers to a program code and the parameter information for the second processor to generate one or more object codes. A second linker links the generated one or more object codes to generate an execution file for the second processor.

Abstract: A compiled program has an advanced-load instruction and a load-checking atomic section. The load-checking atomic section follows the advanced-load instruction in the compiled program. The advanced-load instruction, when executed, loads a value from a shared memory address. The load-checking atomic section includes a check instruction for checking the validity of the shared memory address.

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

Abstract: A branch prediction mechanism within an information processing device comprises a call stack where function arguments are stacked when function calls are performed. The call stack stores arguments relating to branch instructions within the function. The branch prediction mechanism stores the branch instruction address, the leading value of the call stack, and the branch destination address at branch instruction execution time, which are in correspondence, in a branch result buffer. A branch prediction unit obtains the branch instruction address and leading value of the call stack when notified of branch instruction execution, searches the branch result buffer for a branch destination corresponding to the address and leading value, and predicts the search result as the branch destination of the executed branch instruction. An instruction fetch unit fetches instructions from the branch destination predicted by the branch prediction unit.

Abstract: Methods, systems, computer-readable media, and apparatus for determining function side effects of a program function are disclosed. Source code of one or more prototype functions that is configured to simulate the function side-effect behaviors of a program function can be provided, and the compiler can determine the functional side effects of the program function in various specific program contexts based on the source code of the prototype functions rather than the source code of the program function. Optimization procedures can be performed based on the function side effects of the program function derived from the prototype functions and the program contexts.

Abstract: Providing change information includes obtaining information of a change track that changes software source code, wherein the change track includes a change item, identifying at least one preliminary candidate change item from the change item, wherein the preliminary candidate change item is a change item causing execution of the source code to change, and inserting an instrument in the source code at a location corresponding to the at least one preliminary candidate change item so information of at least one candidate change item is outputted in testing the source code using a test case. The at least one candidate change item is a change item related to the test case from the at least one preliminary candidate change item. The information of a change track is combined with the information of a candidate change item. The change-related information is provided based on the result of the combination.