Abstract:
The present invention relates in a first aspect to a computer-implemented method (1) comprising obtaining (2) an intermediate computer code object comprising at least one set of instructions corresponding to a task to be performed, the intermediate computer code object – being machine independent - further comprising for each of said at least one set of instructions one or more metadata descriptors representative of at least a complexity measure of the task to be performed. The method also comprises executing (4) the intermediate computer code object on a computing platform comprising at least two different execution units having a different memory with a different memory location. This executing comprises selecting (6) for each of the at least one set of instructions a target execution unit from the plurality of execution units. This selecting takes the one or more metadata descriptors and a decision rule into account, wherein the decision rule relates the plurality of complexity measures to a performance characteristic of the plurality of execution units.
Abstract:
Technology is disclosed for sharing an authentication profile of a user between a group of user devices for accessing an access restricted computing environment ("the technology"). The access restricted computing environment can require the user to input authentication information, such as a username, password, or answers to challenge questions, to authenticate the user. For example, to access a wireless network on a first user device, a user may have to input a password for the wireless network. To access the same wireless network on a second user device, the user may have to input the password again on the second user device. The technology facilitates the user to obtain the authentication information required to access the wireless network from another user device, e.g., a device from which the user has accessed the wireless network previously. This can eliminate the need for the user to manually input the authentication information repeatedly.
Abstract:
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.
Abstract:
Various embodiments of the present invention provide systems and methods of converting data used for shipment rate calculations into executable code. More specifically, certain embodiments of the present invention provide systems and methods of converting data used for shipment rate calculations into executable code by scanning the data from at least one source file, parsing the data in accordance with a template, and generating the executable code by utilizing the parsed data. As a result, the code may be executed to provide the data used for shipment rate calculations without having to access the original source file. In addition, compiling such data into executable code may improve look-up performance, may provide encapsulation of logic related to the specific nature of the data, and may provide a mechanism by which the raw data is not overtly exposed to end users of the software and third-parties.
Abstract:
A system for use with a compiler architecture framework, includes performing a statically speculative compilation process to extract and use speculative static information, (2) encoding the speculative static information in an instruction set architecture of a processor, (3) and executing a compiled computer program using the speculative static information, wherein executing supports static speculation driven mechanisms and controls (5).
Abstract:
The invention relates to an apparatus (100) for processing an abstract syntax tree being associated with a source code of a source program, the abstract syntax tree comprising a plurality of nodes, the apparatus (100) comprising a code virtualizer (101) being configured to associate the plurality of nodes of the abstract syntax tree with a plurality of calls of a target application programming interface upon the basis of a predetermined mapping data structure, the predetermined mapping data structure indicating semantic associations between the plurality of nodes and the plurality of calls, and to generate a virtualized code upon the basis of the plurality of nodes, the virtualized code indicating the plurality of calls of the target application programming interface.
Abstract:
The invention relates to a method for compiling a source code to a program code, the method comprising: providing (101) a pattern graph based on the source code, the pattern graph corresponding to an intermediate representation of the source code according to a set of rules in a first programming language, wherein the set of rules comprises a specific replacement rule directing a pattern graph to be replaced by a corresponding replacement graph assigned to the pattern graph, replacing (103) the pattern graph by the replacement graph assigned to the pattern graph, and generating (105) the program code based on the replacement graph.
Abstract:
Methods, devices, and systems for automatically determining how an application program may be partitioned and offloaded for execution by a general purpose applications processor and an auxiliary processor (e.g., a DSP, GPU, etc.) within a mobile device. The mobile device may determine the portions of the application code that are best suited for execution on the auxiliary processor based on pattern-matching of directed acyclic graphs (DAGS). In particular, the mobile device may identify one or more patterns in the code, particularly in a data flow graph of the code, comparing each identified code pattern to predefined graph patterns known to have a certain benefit when executed on the auxiliary processor (e.g., a DSP). The mobile device may determine the costs and/or benefits of executing the potions of code on the auxiliary processor, and may offload portions that have low costs and/or high benefits related to the auxiliary processor.
Abstract:
The invention relates to a method (800) for constructing a graph data structure as an intermediate representation of source code for a compiler configured for compiling the source code into executable machine code running on a processor of a computer system, wherein program operations of the source code are represented in an object-oriented programming language by objects of classes that form a hierarchy growing from a base node class of the graph data structure, the method (800) comprising: producing new nodes (801) of the graph data structure by calling factory methods associated with existing nodes of the graph data structure based on a factory method design pattern implemented in the nodes of the graph data structure, wherein the nodes of the graph data structure are identified by symbols; and using the symbols as proxies of the nodes (803) of the graph data structure according to a proxy design pattern.
Abstract:
Hardware compilation and/or translation with fault detection and roll back functionality are disclosed. Compilation and/or translation logic receives programs encoded in one language, and encodes the programs into a second language including instructions to support processor features not encoded into the original language encoding of the programs. In one embodiment, an execution unit executes instructions of the second language including an operation-check instruction to perform a first operation and record the first operation result for a comparison, and an operation-test instruction to perform a second operation and a fault detection operation by comparing the second operation result to the recorded first operation result. In some embodiments, an execution unit executes instructions of the second language including commit instructions to record execution checkpoint states of registers mapped to architectural registers, and roll-back instructions to restore the registers mapped to architectural registers to previously recorded execution checkpoint states.