Dynamic allocation of executable code for multi-architecture heterogeneous computing - Patents.com

Abstract

An apparatus for executing a software program includes a processing unit and a hardware processor, the hardware processor being adapted for: generating target side instructions using the target side blocks in an intermediate representation of the software program, the intermediate representation including blocks, each block being associated with an execution block of the software program, the intermediate representation including intermediate instructions identifying a caller block and a target side block, the caller block including control flow intermediate instructions for executing target side intermediate instructions of the target side block; generating call instructions using the caller block and computer control instructions for calling the target side instructions when the call instructions are executed by the caller processing unit and the target side instructions are executed by the target side processing unit; configuring the caller processing unit to execute the call instructions; and configuring the target side processing unit to execute the target side instructions.

Description

[Technical field]

[0001] Related Applications This application claims the benefit of priority to U.S. patent application Ser. No. 17 / 172,134, filed Feb. 10, 2021, which issued as U.S. Patent No. 11,113,059 on Sep. 7, 2021, the entire contents of which are incorporated herein by reference. [Background technology]

[0002] Some embodiments described in this disclosure relate to computing devices, and more particularly, but not exclusively, to heterogeneous multi-architecture computing systems.

[0003] In the field of computing, the term performance refers to the amount of useful work performed by a computer processing system. Some characteristics of useful work include the speed at which the work is performed, the utilization of computing resources (such as the amount of memory used or the amount of network bandwidth consumed), and the time it takes a computer processing system to react to an input. There are various metrics for measuring the amount of useful work. Some metrics are specific to the context of computer processing systems, while some others are general metrics that can be measured on a variety of computer processing systems.

[0004] As used herein, the term "processing unit" is used to mean any kind of programmable or non-programmable circuitry configured to perform a set of operations. A processing unit may comprise hardware as well as software. For example, a processing unit may include one or more processors and a temporary or non-transient memory that holds programs that cause the processing unit to perform respective operations when the programs are executed by the one or more processors.

[0005] Further, as used herein, the term "improving performance" refers to improving one or more performance scores measured or calculated according to one or more performance metrics. Two common metrics used to measure the performance of a processing unit are latency and throughput. Latency is the time it takes a processing unit to perform an identified operation. Some examples of identified operations are delivering a data packet from a source to a destination and executing an identified set of computer instructions in response to input values. Improving latency refers to decreasing the time it takes a processing unit to perform an identified operation. Throughput is the amount of identified operations a processing unit performs within a time interval, e.g., the amount of data packets delivered during that time interval. Another example of the throughput of a system is the amount of input values ​​a processing unit executes an identified set of computer instructions within a time interval. Improving throughput refers to increasing the amount of identified operations a processing unit executes within a time interval.

[0006] In the computing field, the term coprocessor is used to describe an auxiliary processing unit that is used to complement the primary processing unit of a system and facilitates improved system performance by offloading some of the processor-intensive tasks from the primary processing unit. As the demand for high performance computing increases, the use of coprocessing to improve performance is on the rise. Some coprocessors are designed to perform unique tasks. A commonly known coprocessor is a floating-point processor for performing floating-point arithmetic tasks. Other examples of unique tasks that may be performed by a coprocessor include network input-output interface tasks, encryption, string processing, graphics processing, linear algebra processing, machine learning processing, and signal processing. Other coprocessors may be configured to perform any part of a computer program that is not characterized as a unique task.

[0007] Coprocessing is distinct from distributed processing. In a distributed system, a problem is divided into multiple independent tasks, each of which is solved by one or more of multiple processing units operating substantially independently of each other, and possibly communicating between them. In coprocessing, the coprocessor complements the functionality of the primary processing unit and works in conjunction with the primary processing unit.

[0008] It is necessary to delegate parts of a computer program to be executed by one or more coprocessors. Summary of the Invention

[0009] Some embodiments of the present disclosure describe executing software programs on a heterogeneous computing system, the heterogeneous computing system including multiple processing units, each processing unit having one of multiple computer architectures.

[0010] These and other objects are achieved by means of the features of the independent claims. Further embodiment forms are evident from the dependent claims, the description and the drawing.

[0011] These and other objects are achieved by means of the features of the independent claims. Further embodiment forms are evident from the dependent claims, the description and the drawing.

[0012] According to a first aspect of the present invention, an apparatus for executing a software program includes a plurality of processing units and at least one hardware processor, the at least one hardware processor being adapted for: identifying, in an intermediate representation of a software program comprising a plurality of blocks, each block being associated with one of a plurality of execution blocks of the software program and comprising an intermediate instruction set, a caller block comprising at least one control flow intermediate instruction for executing at least one target side intermediate instruction of the target side block; generating a target side executable instruction set using the target side blocks; generating a caller executable instruction set using the caller block and using at least one computer control instruction for calling the target side executable instruction set when the caller executable instruction set is executed by the caller processing unit and the target side executable instruction set is executed by the target side processing unit; configuring the caller processing unit to execute the caller executable instruction set; and configuring the target side processing unit to execute the target side executable instruction set. Identifying the caller block and the target block in the intermediate representation of the software program enables dynamic generation of the caller executable instruction set and additional or alternative target executable instruction sets, such as during runtime of the software program, thereby enabling dynamic configuration of the caller processing unit and additional or alternative target processing units. The dynamic configuration of the caller processing unit and additional or alternative target processing units facilitates improving the performance of a system executing the software program by delegating execution of the caller block and additional or alternative target blocks to one or more coprocessors.

[0013] According to a second aspect of the present invention, a method for executing a software program includes identifying, in an intermediate representation of the software program comprising a plurality of blocks, each block being associated with one of a plurality of execution blocks of the software program and comprising an intermediate instruction set, a caller block comprising at least one control flow intermediate instruction for executing at least one target intermediate instruction of the target block, and a target block, generating a target executable instruction set using the target block, and if the caller executable instruction set is executed by a caller processing unit of the plurality of processing units and the target executable instruction set is executed by a target processing unit of the plurality of processing units, generating a caller executable instruction set using the caller block and using at least one computer control instruction for calling the target executable instruction set, configuring the caller processing unit to execute the caller executable instruction set, and configuring the target processing unit to execute the target executable instruction set.

[0014] According to a third aspect of the present invention, a software program product for executing a software program comprises a non-transitory computer readable storage medium; an intermediate representation of the software program comprising a plurality of blocks, each block being associated with one of a plurality of execution blocks of the software program and comprising an intermediate instruction set; first program instructions for identifying in the intermediate representation a caller block comprising at least one control flow intermediate instruction for executing at least one target side intermediate instruction of the target side block; second program instructions for generating a target side executable instruction set using the target side block; and a program instruction for generating a target side executable instruction set for execution by the caller processing unit of the plurality of processing units. and when the target executable instruction set is executed by a target processing unit of the plurality of processing units, the program further comprises third program instructions for generating the caller executable instruction set using the caller block and using at least one computer control instruction for calling the target executable instruction set, fourth program instructions for configuring the caller processing unit to execute the caller executable instruction set, and fifth program instructions for configuring the target processing unit to execute the target executable instruction set, wherein the first, second, third, fourth and fifth program instructions are executed by the at least one computer processor from a non-transitory computer readable storage medium.

[0015] Referring to the first and second aspects, in a first possible implementation of the first and second aspects of the present invention, a first computer architecture of the calling processing unit is different from a second computer architecture of the target processing unit. Optionally, at least one of the first computer architecture and the second computer architecture is selected from the group of computer architectures consisting of a complex instruction set computer (CISC) architecture, a reduced instruction set computer (RISC) architecture, an x86 family-based computer architecture, an IBM (International Business Machine) Power family-based computer architecture, and an ARM family-based computer architecture. Optionally, the target processing unit is selected from a group of processing units consisting of a central processing unit, a multi-core central processing unit (CPU), a data processing unit (DPU), a microcontroller unit (MCU), an accelerated processing unit (ACU), a field programmable gate array (FPGA), a coarse-grained reconfigurable architecture (CGRA), a neural network accelerator, an intelligence processing unit (IPU), an application specific integrated circuit (ASIC), a quantum computer, and an interconnected computing grid including a plurality of reconfigurable logic elements connected by a plurality of configurable data routing junctions. Optionally, the caller executable instruction set includes a plurality of conversion instructions implementing an application binary interface applied to at least one control flow intermediate instruction to convert between a first computer architecture of the caller processing unit and a second computer architecture of the target processing unit.Optionally, the target side block includes a plurality of target side metadata values, and generating the target side executable instruction set includes generating a plurality of transformed target side metadata values ​​using the plurality of target side metadata values ​​according to a second computer architecture of the target side processing unit. Using a caller processing unit having a computer architecture different from another computer architecture of the target side processing unit facilitates reducing implementation costs, and additionally or alternatively operating costs, of a system implemented in accordance with the present disclosure without significantly impacting system performance when executing the software program by allowing at least one of the caller processing unit and the target side processing unit to be designed to be less expensive and additionally or alternatively to consume less power than the other respective processing unit. Implementing an application binary interface applied to one or more control flow intermediate instructions facilitates delegation of the target side block to the target side processing unit for execution by the caller executable instruction set, thereby improving system performance when executing the software program. By generating a plurality of transformed target metadata values ​​using a plurality of target metadata values ​​in accordance with a second computer architecture of the target processing unit, execution of the target executable instruction set by the target processing unit and execution of the call executable instruction set by the call processing unit are facilitated in a common execution context, thereby providing greater flexibility in identifying target blocks for transfer to the target processing unit for execution and improving system performance when executing a software program.

[0016] With reference to the first and second aspects, in a second possible implementation of the first and second aspects of the present invention, the target processing unit is further configured to provide to the caller processing unit at least one value generated by the target processing unit executing at least some of the target instruction set. Optionally, the caller processing unit is further configured to receive from the caller processing unit at least one value generated by the target processing unit executing at least some of the target instruction set. Optionally, the caller processing unit is further configured to provide to the target processing unit at least one argument value. Providing to the caller processing unit one or more values ​​generated by the target processing unit executing at least some of the target instruction set, and additionally or alternatively providing to the target processing unit by the caller processing unit one or more argument values, facilitates delegation of target blocks to the target processing unit for execution, thereby improving the performance of a system implemented according to the present disclosure when executing a software program.

[0017] With reference to the first and second aspects, in a third possible implementation of the first and second aspects of the present invention, the target processing unit is further configured to instruct the caller processing unit to execute at least some of the caller executable instruction set after executing at least some others of the target instruction set. Optionally, the caller processing unit is further configured to suspend execution of the caller executable instruction set after executing at least one computer control instruction for invoking the target executable instruction set, and execute at least some of the caller executable instruction set in response to receiving instructions from the target processing unit. Invoking execution of at least some of the caller executable instruction set by the target processing unit facilitates providing the target processing unit access to one or more computing resources connected to the target processing unit, thereby improving flexibility in identifying target blocks to be delegated to the target processing unit for execution and improving system performance when running software programs.

[0018] With reference to the first and second aspects, in a fourth possible implementation of the first and second aspects of the present invention, the caller executable instruction set includes at least one first memory access instruction to at least one memory address within an identification range of application memory addresses, and the target executable instruction set includes at least one second memory access instruction to at least one other memory address within the identification range of application memory addresses. Optionally, the identification range of application memory addresses is one of a physical memory address range, a virtual memory address range, a memory mapped I / O address range, and a bus address range. Accessing the identification range of application memory addresses by both the caller executable instruction set and the target executable instruction set provides increased flexibility in identifying target blocks for delegation to a target processing unit for execution, improving system performance when executing a software program.

[0019] With reference to the first and second aspects, in a fifth possible implementation of the first and second aspects of the present invention, the caller executable instruction set includes accessing the at least one device using at least one device handle associated with the at least one device, and the target executable instruction set includes accessing the at least one device using the at least one device handle. Optionally, the at least one device handle is at least one of a network socket handle, an operating system kernel object handle, and a file descriptor. Accessing one or more devices by both the caller executable instruction set and the target executable instruction set provides increased flexibility in identifying target blocks for delegation to a target processing unit for execution, improving system performance.

[0020] With reference to the first and second aspects, in a sixth possible implementation of the first and second aspects of the present invention, the at least one hardware processor is further adapted to collect a plurality of statistics while executing at least a portion of the software program, and identify the caller block and the target block according to the plurality of statistics. Optionally, at least one of the plurality of statistics indicates one of an outcome of executing a control flow instruction, a data value of a variable of the software program, a memory access pattern, and a memory virtual address translation. Optionally, the at least one hardware processor is further adapted to insert a plurality of telemetry intermediate instructions into the intermediate representation of the software program for the purpose of collecting the plurality of statistics. Identifying the caller block and the target block according to the plurality of statistics improves the accuracy of the identification, thereby improving system performance when executing the software program.

[0021] With reference to the first and second aspects, in a seventh possible implementation of the first and second aspects of the present invention, the caller processing unit is at least one hardware processor. Having one or more hardware processors that identify the caller and target blocks executing the caller executable instruction set enables run-time identification of the caller and target blocks and improves the accuracy of that identification, thereby improving system performance when running the software program.

[0022] Other systems, methods, features, and advantages of the present disclosure will be or become apparent to one with skill in the art upon examination of the following figures and detailed description, and it is intended that all such additional systems, methods, features, and advantages be included within this description, be within the scope of the present disclosure, and be protected by the accompanying claims.

[0023] Unless otherwise defined, all technical and / or scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art of the embodiments. Although methods and materials similar or equivalent to those described herein can be used to practice or test the embodiments, exemplary methods and / or materials are described below. In case of conflict, the patent specification, including definitions, will control. Furthermore, the materials, methods, and examples are illustrative only and are not intended to be necessarily limiting.

[0024] Some embodiments are herein described, by way of example only, with reference to the accompanying drawings, in which: Reference will now be made specifically to the drawings in detail, with it being stressed that the particulars shown are for the purpose of illustrating and discussing the embodiments by way of example, and in this regard the description using the drawings will make apparent to those skilled in the art how the embodiments may be practiced. [Brief description of the drawings]

[0025] [Figure 1] 1 is a schematic block diagram of an exemplary software program according to some embodiments. [Diagram 2] 1 is a schematic block diagram of an exemplary apparatus for executing software programs in accordance with some embodiments. [Diagram 3] 1 is a flowchart that generally illustrates an optional operational flow according to some embodiments. [Figure 4] FIG. 11 is a sequence diagram of another optional operational flow according to some embodiments. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0026] Some coprocessors operate independently without being invoked by the system's primary processing unit (for example, a network interface coprocessor can process received network packets with little, if any, involvement of the primary processing unit). Other coprocessors receive instructions from the primary processing unit (for example, a graphics processing unit (GPU) receives instructions for rendering digital images).

[0027] When two processing units of a system work in conjunction, it may be necessary for a caller processing unit to invoke an operation on a target processing unit, e.g., for a primary processing unit to invoke a coprocessor. In another example, a coprocessor may invoke a primary processing unit to access resources that the coprocessor cannot access independently, e.g., non-volatile digital storage. In addition to the caller processing unit invoking the target processing unit, it may be necessary to receive one or more data values, e.g., input arguments of an operation performed by the target processing unit, from the caller processing unit and pass them to the target processing unit. Additionally, it may be necessary to receive one or more other data values, such as an outcome value calculated by the target processing unit, from the target processing unit and pass them back to the caller processing unit.

[0028] In computing, the term Application Binary Interface (ABI) refers to an interface between two binary program modules that describes in a hardware-dependent format how to access data and computational routines. The interface between two binary program modules may include the format of data structures. Additionally or alternatively, the interface may include caller conventions for providing data as input to the computational routines and additionally or alternatively for reading data as output from the computational routines.

[0029] In computing, the term architecture refers to the organization of components that make up a computer system and the semantics or meaning of operations that guide the functioning of the computer system. As used herein, the term "homogeneous system" refers to a computing system that includes multiple processing units that all have a common architecture. For example, a computing system that includes multiple central processing units (CPUs) that have a common architecture is a homogeneous system. Similarly, the term "heterogeneous system" refers to a system that includes multiple processing units, where at least one of the multiple processing units has an architecture that is different from another architecture of another of the multiple processing units. For example, a system that includes a CPU and a GPU is a heterogeneous system. Another example of a heterogeneous system is a system that includes a CPU and a field programmable gate array (FPGA) coprocessor. Another example of a heterogeneous system is a system that includes a CPU that has a complex instruction set computer (CISC)-based architecture and another CPU that has a reduced instruction set computer (RISC)-based architecture. An additional example of a heterogeneous system is a system having two or more CPUs, each supporting a different instruction set architecture (ISA), for example, one CPU supporting the Intel x86 ISA and another supporting the Motorola 68000 series ISA, or one CPU supporting the ARM ISA and another supporting the RISC-V ISA. In yet another example of a heterogeneous system, the heterogeneous system has a high performance CPU that consumes high power and an efficient CPU that consumes low power.

[0030] When executing a software program that includes multiple execution blocks having a caller execution block and a target execution block, the caller execution block is said to call the target execution block if the caller execution block includes one or more control flow instructions for executing one or more instructions of the target caller block. When executing a software program by multiple processing units, the caller processing unit may execute the caller execution block and call the target execution block executed by the target processing unit. In such a case, calling the target execution block by the caller execution block requires generating an instruction set executed by the caller processing unit according to an ABI that describes an interface to the target processing unit, i.e., the instruction set implements the ABI. Optionally, implementing the ABI includes adding one or more conversion instructions to the instruction set for converting between the architecture of the caller processing unit and another architecture of the target processing unit. Optionally, the one or more conversion instructions are added to the instruction set executed by the caller processing unit. Optionally, the one or more conversion instructions are added to other instructions executed by the target processing unit. Optionally, implementing the ABI includes organizing one or more data values ​​in a memory area, such as a stack, according to another architecture of the target unit, e.g., according to another architecture's data encoding, another architecture's byte alignment, and another architecture's byte order.

[0031] Additionally, the execution state of the caller processing unit may need to be provided to the target processing unit via the ABI, for example to share access rights to a file or memory area, and additionally or alternatively to share one or more data values. Other examples of shared execution state include network socket context, a view of a network topology, and a virtualization context such as Single Root Input Output Virtualization (SRIOV). The execution state may include, but is not limited to, one or more of a thread identification value, a process identification value, an instruction address of an instruction to execute after execution of a return instruction (return address), and values ​​of one or more formal arguments of a function. Optionally, the caller execution block and the target execution block access a common range of application memory addresses of the software program. Some examples of application memory addresses include, but are not limited to, physical memory addresses, virtual memory addresses, memory-mapped input / output addresses, and bus addresses. Optionally, the target execution block includes access to one or more devices of the computer processing system, for example, a disk drive or a network adapter. Optionally, one or more device handles associated with the one or more devices need to be provided to the target processing unit via the ABI.

[0032] If one or more execution blocks to be executed by a coprocessor can be identified in advance, and if the coprocessor is known when compiling a software program from source files, then one or more appropriate instruction sets can be generated for directing the coprocessor to execute the one or more execution blocks, however, performance improvements achieved by pre-generating instructions for a coprocessor are limited by the ability to identify tasks that, when delegated to one or more coprocessors, will improve system performance.

[0033] In a homogeneous system, where multiple processing units have a common architecture and therefore a common ABI, an execution block may be compiled to call another execution block executed by another processing unit without determining in advance which of the multiple processing units will execute the other execution block. However, the performance gains achieved in a homogeneous system are limited by the common architecture's support for dynamically allocated tasks. For example, if each of the multiple processing units is a CPU, delegating one or more floating-point arithmetic operations to another CPU may provide less performance gain than delegating one or more floating-point arithmetic operations to a floating-point processor.

[0034] A heterogeneous system optionally includes a first target side processing unit having a first architecture and a second target side processing unit having a second architecture. In such a heterogeneous system, an instruction set executed by a calling processing unit and invoking an execution block executed by the first target side processing unit is generated according to a first ABI of the first architecture. In such a heterogeneous system, the instruction set cannot be used to invoke the same execution block when executed by the second target side processing unit because a second ABI of the second architecture may differ from the first ABI.

[0035] In computer programming, an intermediate representation of a computer program is a representation of a computer program in an abstract machine language that is not dedicated to any particular machine, but which describes the operations of a machine (a processing unit).

[0036] The present disclosure, in some embodiments described herein, proposes to dynamically configure a caller processing unit and a target processing unit using an intermediate representation of a software program. Optionally, the intermediate representation includes a plurality of blocks. According to such embodiments, using the intermediate representation, the caller processing unit is configured to execute a caller block of the plurality of blocks, the target processing unit is configured to execute a target block of the plurality of blocks, and the caller block calls the target block. To do so, in such embodiments, the present disclosure proposes to dynamically generate a caller executable instruction set with the caller block and a target executable instruction set with the target block using the intermediate representation, and to configure the caller processing unit to execute the caller executable instruction set and the target processing unit to execute the target executable instruction set. Optionally, executing the software program includes the caller processing unit executing the caller executable instruction set and the target processing unit executing the target executable instruction set. Optionally, executing the software program includes generating a caller executable instruction set and additionally or alternatively generating a target executable instruction set. Optionally, executing the software program includes configuring the caller processing unit to execute the caller executable instruction set and additionally or alternatively configuring the target processing unit to execute the target executable instruction set. Optionally, the dynamic generation of the caller executable instruction set and the target executable instruction set occurs during run-time, i.e., during just-in-time (JIT) compilation, of the software program. Optionally, a first architecture of the caller processing unit is different from a second architecture of the target processing unit.The use of intermediate representations of the multiple blocks enables dynamic generation of call and target executable instruction sets and enables dynamic configuration of the call and target processing units, thereby enabling dynamic selection of the call and target processing units from the multiple processing units. The dynamic configuration of the call and target processing units facilitates improved system performance during execution of the software program, for example, improved latency and additionally or alternatively improved throughput, as compared to static configuration of the call and target processing units.

[0037] A block of the multiple blocks of the intermediate representation may call another block of the intermediate representation by including one or more control flow intermediate instructions for executing one or more intermediate instructions of the other block. Examples of control flow intermediate instructions include a function call intermediate instruction, a jump intermediate instruction, and a conditional branch intermediate instruction. Optionally, a caller block and a target block are identified such that the caller block includes one or more control flow intermediate instructions for executing one or more target intermediate instructions of the target block.

[0038] Furthermore, the one or more control flow intermediate instructions optionally include the caller processing unit providing one or more input values, e.g., one or more formal arguments of a function, to the target processing unit. Furthermore, the target processing unit is optionally configured to provide one or more values ​​generated by the target processing unit, e.g., an execution outcome of a target block, to the caller processing unit.

[0039] Further, in some embodiments described herein, the caller block and the target block are identified according to a plurality of statistics collected during the execution of at least a portion of the software program. Some examples of statistics are outcomes of executing control flow instructions, data values ​​of variables of the software program, memory access patterns, and memory virtual address translations. Statistics such as these allow for the identification of one or more possible paths of execution of the software program. Identifying the caller block and the target block according to the plurality of statistics increases the accuracy of identifying the caller block and the target block in a manner that improves system performance when executing the software program. Optionally, a plurality of telemetry intermediate instructions are inserted into the intermediate representation of the software program for the optional purpose of collecting the plurality of statistics.

[0040] Before describing at least one embodiment in detail, it is to be understood that the embodiments are not necessarily limited in their application to the details of construction and the arrangement of components and / or methods set forth in the following description and / or illustrated in the drawings and / or examples. Implementations described herein are capable of other embodiments or of being practiced or carried out in various ways.

[0041] The embodiments may be systems, methods, and / or computer program products. The computer program product may include computer readable storage medium(s) having computer readable program instructions thereon for causing a processor to perform aspects of the embodiments.

[0042] A computer-readable storage medium may be a tangible device that can hold and store instructions for use by an instruction execution device. A computer-readable storage medium may be, for example, but is not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination thereof. Non-exhaustive examples of more specific computer-readable storage media include: portable computer diskettes, hard disks, random access memories (RAMs), read-only memories (ROMs), erasable programmable read-only memories (EPROMs or flash memories), static random access memories (SRAMs), portable compact disk read-only memories (CD-ROMs), digital versatile disks (DVDs), memory sticks, floppy disks, and any suitable combinations of the above. As used herein, a computer-readable storage medium should not be interpreted as a transitory signal in itself, such as an electric wave or other freely propagating electromagnetic wave, an electromagnetic wave propagating through a wave guide or other transmission medium (e.g., a light pulse passing through a fiber optic cable), or an electrical signal transmitted through an electrical wire.

[0043] The computer readable program instructions described herein can be downloaded from the computer readable storage medium to each computing / processing device or to an external computer or external storage device via a network, such as the Internet, a local area network, a wide area network, and / or a wireless network. The network may include copper transmission cables, optical transmission fiber, wireless transmission, routers, firewalls, switches, gateway computers, and / or edge servers. A network adapter card or network interface of each computing / processing device receives the computer readable program instructions from the network and transfers the computer readable program instructions for storage in a computer readable storage medium within the respective computing / processing device.

[0044] The computer readable program instructions for carrying out the operations of the embodiments may be either source code or object code, natively compiled or just-in-time (JIT) compiled, written in any combination of one or more programming languages, including interpreted programming languages ​​such as Smalltalk, C++, Java, object-oriented Fortran, JavaScript, object-oriented programming languages ​​such as Python or others, and traditional procedural programming languages ​​such as the "C" programming language, Fortran, or similar programming languages. The computer readable program instructions may run entirely on the user's computer, partially on the user's computer as a stand-alone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer via any type of network, including a local area network (LAN) or wide area network (WAN), or may be connected to an external computer (e.g., via the Internet using an Internet Service Provider). In some embodiments, electronic circuitry including, for example, a programmable logic circuit, a field programmable gate array (FPGA), or a programmable logic array (PLA), may execute computer readable program instructions by utilizing state information of the computer readable program instructions to personalize the electronic circuitry to implement aspects of the embodiments.

[0045] Aspects of the embodiments are described herein with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems) and computer program products according to the embodiments. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer readable program instructions.

[0046] These computer readable program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing unit to produce a machine such that the instructions, executed by the processor of the computer or other programmable data processing unit, create means for performing the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams. These computer readable program instructions may also be stored on a computer readable storage medium that has instructions stored therein that can direct a computer, programmable data processing unit, and / or other device to function in a particular manner, such as to include an article of manufacture that includes instructions that implement aspects of the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams.

[0047] Furthermore, computer-readable program instructions can be loaded into a computer, other programmable data processing unit, or other device to execute a series of operational steps on the computer, other programmable data processing unit, or other device to generate a computer-implemented process such that the instructions executing on the computer, other programmable data processing unit, or other device perform the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams.

[0048] The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments. In this regard, each block in the flowcharts or block diagrams may represent a module, segment, or portion of instructions, including one or more executable instructions for implementing a specified logical function(s). In some alternative implementations, the functions noted in the blocks may occur out of the order noted in the figures. For example, two blocks shown in succession may in fact be executed substantially simultaneously, or the blocks may sometimes be executed in reverse order, depending on the functionality involved. It should also be noted that each block of the block diagrams and / or flowchart diagrams, and combinations of blocks in the block diagrams and / or flowchart diagrams, may be implemented by a special-purpose hardware-based system that performs the specified functions or acts, or a combination of special-purpose hardware and computer instructions.

[0049] 1, a schematic block diagram of an exemplary software program 100 is shown, according to some embodiments. In such embodiments, the source code 101 of the software program includes multiple execution blocks, having a caller execution block 110 and a target execution block 120. Optionally, the caller execution block 110 calls the target execution block 120. Optionally, the caller execution block 110 includes one or more control flow source code instructions for executing one or more source code instructions of the target execution block 120.

[0050] Optionally, the intermediate representation 102 is a representation of the source code 101 that is not specific to a computer architecture, such as an intermediate language. Examples of intermediate languages ​​used for the intermediate representation include a register transfer language (RTL), the C programming language, MATLAB precompiled code, the LLVM Developer Group intermediate representation language, the GNU Compiler Collection intermediate representation language, Microsoft P-code, and Java bytecode. Optionally, the intermediate representation 102 is a language that targets a virtual machine. Optionally, the intermediate representation 102 includes a plurality of blocks having a caller block 111 and a target block 121. Optionally, each of the plurality of blocks is associated with one of the plurality of execution blocks of the source code 101 and includes a plurality of intermediate instructions. In this example, the caller block 111 is associated with the caller execution block 110, and the target block 121 is associated with the target execution block 120.

[0051] In an association between each of the multiple blocks on the intermediate representation 102 and one of the multiple execution blocks of the source code 101, the intermediate representation 102 optionally holds an execution block 110 that calls an execution block 120. Optionally, the caller block 111 includes one or more control flow intermediate instructions for executing one or more target side intermediate instructions of the target side block 121.

[0052] For execution of the software program on one or more processing units, one or more executable instruction sets are generated for each of the blocks of the intermediate representation 102. Thus, a caller executable instruction set 112 is optionally generated for the caller block 111, and a target executable instruction set 122 is optionally generated for the target block 121.

[0053] Referring now also to Figure 2, a schematic block diagram of an exemplary apparatus 200 for executing a software program is shown, according to some embodiments. In such embodiments, at least one hardware processor 201 is connected to a plurality of processing units, including, for example, a caller processing unit 210 and a target processing unit 220. Optionally, one or more of the plurality of processing units is selected from a group of processing units, including, but not limited to, a central processing unit, a multi-core central processing unit (CPU), a data processing unit (DPU), a microcontroller unit (MCU), an accelerated processing unit (ACU), a field programmable gate array (FPGA), a coarse-grained reconfigurable architecture (CGRA), a neural network accelerator, an intelligent processing unit (IPU), an application specific integrated circuit (ASIC), a quantum computer, and an interconnected computing grid including a plurality of reconfigurable logic elements connected by a plurality of configurable data routing junctions.

[0054] Optionally, the caller processing unit has a first computer architecture selected from a group of computer architectures including, but not limited to, a complex instruction set computer (CISC) architecture, a reduced instruction set computer (RISC) architecture, an x86 family-based computer architecture, an IBM (International Business Machine) Power family-based computer architecture, and an ARM family-based computer architecture. Optionally, the target processing unit has a second computer architecture selected from a group of computer architectures. Optionally, the first computer architecture is different from the second computer architecture. Optionally, the first computer architecture is the second computer architecture.

[0055] Optionally, the at least one hardware processor 201 is connected to the multiple processing units via one or more digital communication networks, for example, a local area network (LAN) such as an Ethernet network or a Wi-Fi network, or a wide area network (WAN) such as the Internet. Optionally, the caller processing unit 210 is connected to the target processing unit 220, optionally via a digital communication network. Optionally, the target processing unit 220 is electrically coupled to the caller processing unit 210, for example, via a memory bus, a peripheral component expansion bus, or an interconnect, for example, Intel QuickPath Interconnect (QPI) and Peripheral Component Interconnect Express (PCIe).

[0056] Optionally, the device 200 includes a memory 230, optionally connected to one or more of the processing units. Optionally, the memory 230 is a random access memory (RAM), including, for example, a static RAM (SRAM), and additionally or alternatively, a dynamic RAM (DRAM). Examples of DRAM include synchronous dynamic RAM (SDRAM), double data rate SDRAM (DDR), graphics double data rate SDRAM (GDDR), and low power double data rate SDRAM (LPDDR), as well as high bandwidth RAM (HBM). Optionally, the device 200 includes a non-volatile digital storage 233, optionally connected to one or more of the processing units. Examples of non-volatile digital storage include a hard disk drive, a solid state drive, a network attached storage, and a storage network.

[0057] Optionally, the apparatus 200 includes one or more other devices 231, optionally connected to one or more of the processing units. Examples of devices include a display device and a network adapter. Optionally, the one or more other devices 231 are electrically coupled to the one or more processing units.

[0058] For the sake of simplicity, hereinafter the term "processing unit" will also be used to mean "at least one hardware processor".

[0059] In some embodiments, to execute the software program 100, the device 200 implements the following optional methods.

[0060] Referring now also to Figure 3, a flow chart is shown that generally depicts an operational flow of operation 300, according to some embodiments. In such embodiments, at 301, the processing unit 201 identifies a caller block 111 and a target block 121 within a plurality of blocks of the intermediate representation 102. Optionally, the caller block 111 includes one or more control flow intermediate instructions for executing one or more target-side intermediate instructions of the target block 121. At 311, the processing unit 201 optionally generates a target-side executable instruction set 122 using the target block 121.

[0061] At 313, the processing unit 201 uses the caller block 111 and optionally generates the caller executable instruction set 112 using one or more computer control instructions. Optionally, the one or more computer control instructions call the target executable instruction set 122 when the caller executable instruction set 112 is executed by the caller processing unit 210 and the target executable instruction set 122 is executed by the target processing unit 220. Optionally, the caller executable instruction set 112 includes a plurality of conversion instructions that implement an ABI applied to one or more control flow intermediate instructions to convert between a first computer architecture of the caller processing unit 210 and a second computer architecture of the target processing unit 220.

[0062] Optionally, the target side block 121 includes a plurality of target side metadata values. Optionally, some of the plurality of target side metadata values ​​describe an execution context for executing the target side block 121. Examples of target side metadata values ​​include stack memory values ​​and program counter values. Optionally, generating the target side executable instruction set 122 includes generating a plurality of target side metadata values ​​transformed using the plurality of target side metadata values ​​according to a second computer architecture of the target side processing unit 220.

[0063] Optionally, both the caller executable instruction set 112 and the target executable instruction set 122 access a common range of application memory addresses, such that the caller executable instruction set 112 includes one or more first memory access instructions to one or more memory addresses in the common range of application memory addresses, and the target executable instruction set 122 includes one or more second memory access instructions to one or more other memory addresses in the common range of application memory addresses. Optionally, the common range of application memory addresses is a range of physical memory addresses, e.g., a range of physical addresses in memory 230. Optionally, the common range of application memory addresses is a range of virtual memory addresses. Optionally, the common range of application memory addresses is a range of bus addresses. Optionally, the common range of application memory addresses is a range of memory mapped I / O addresses.

[0064] Optionally, the caller executable instruction set 112 and the target executable instruction set 122 share a common execution state, for example to provide common access privileges. Optionally, a caller thread identifier of the caller executable instruction set 112 is associated with a target thread identifier of the target executable instruction set 122. In a possible example, both the caller executable instruction set 112 and the target executable instruction set 122 access one or more devices 231 using a common device handle. Examples of device handles include network socket handles, operating system kernel object handles, and file descriptors. Thus, in this example, the caller executable instruction set 112 includes accessing one or more devices 231 using one or more device handles associated with the one or more devices 231, and in this example, the target executable instruction set 122 includes accessing one or more devices 231 using one or more device handles.

[0065] Optionally, at 321, the processing unit 201 configures the caller processing unit 210 to execute the caller executable instruction set 112. Optionally, at 323, the processing unit 201 configures the target processing unit 220 to execute the target executable instruction set 122.

[0066] Optionally, the caller processing unit 210 is processing unit 201, such that processing unit 201 is configured to execute the caller executable instruction set 112. Optionally, processing unit 201 executes method 300 while executing software program 100, i.e., JIT compilation.

[0067] When executing the software program 100, the caller processing unit 210 and the target processing unit 220 can communicate with each other.

[0068] Referring now also to FIG. 4, a sequence diagram of another optional flow of operations 400 according to some embodiments is shown. In such embodiments, at 401, the caller processing unit 210 executes one or more computer control instructions for invoking the target side executable instruction set 122. Optionally, configuring the caller processing unit 210 to execute the one or more computer control instructions includes configuring the caller processing unit 210 to provide one or more argument values ​​to the target side processing unit 220, such that at 401, the caller processing unit 210 optionally provides one or more argument values ​​to the target side processing unit 220. Optionally, at 402, the target side processing unit 220 executes at least some of the target side executable instruction set 122. Optionally, at 402, the target side processing unit 220 generates one or more values. Optionally, configuring target processing unit 220 to execute target executable instruction set 122 includes configuring target processing unit 220 to provide one or more values ​​to caller processing unit 210, such that, at 410, target processing unit 220 optionally provides the one or more values ​​to caller processing unit 210. Optionally, configuring caller processing unit 210 includes configuring caller processing unit 210 to receive the one or more values, such that, at 413, caller processing unit 210 optionally receives the one or more values.

[0069] Optionally, the target side block 111 returns control of the execution of the software program 100 to the caller block 112. Optionally, the processing unit 201 optionally further configures the target side processing unit 220 to instruct the caller processing unit 210 to execute at least some of the caller executable instruction set 112, so that, at 420, the target side processing unit 220 optionally instructs the caller processing unit 210 to execute at least some of the caller executable instruction set 112, and, at 422, the caller processing unit 210 optionally executes at least some of the caller executable instruction set 112. Optionally, the target side processing unit 220 instructs the caller processing unit 210 using software signals, which in some examples are operating system process signals, hardware queues, hardware mailboxes, messages, communication pipes, and shared memory areas.

[0070] Optionally, the target side processing unit 220 executes 420 after executing some other ones of the target side executable instruction set 122 .

[0071] Optionally, the caller processing unit 210 is further configured to suspend execution of the caller executable instruction set 112 after executing 401. Optionally, the caller processing unit 210 executes 422 in response to receiving the instruction at 420. Optionally, the target processing unit 220 instructs the caller processing unit 210 to execute at least some of the caller executable instruction set 112 to access resources not shared with the target processing unit 220. Optionally, the target processing unit 220 instructs the caller processing unit 210 to execute at least some of the caller executable instruction set 112 after completing execution of the target executable instruction set 122.

[0072] Referring again to Figure 1 , optionally, at 330, the processing unit 201 collects a plurality of statistics while executing at least a portion of the software program 100. Optionally, at least one of the plurality of statistics is indicative of an outcome of executing a control flow instruction. Optionally, at least one other of the plurality of statistics is indicative of a value of the software program 100, for example an input value to a function or a conditional branch instruction. Optionally, at least one of the plurality of statistics is indicative of a memory access pattern, optionally a plurality of memory accesses to the memory 230. Optionally, the memory access pattern includes an amount of accesses to a memory address or a range of memory addresses. Optionally, at least one of the plurality of statistics is indicative of a memory address translation.

[0073] Optionally, in order to collect the plurality of statistics, the processing unit 201 is further adapted to insert a plurality of telemetry intermediate instructions into the intermediate representation 102. Optionally, the processing unit 201 is further adapted to modify the software program during its execution using hot patch techniques, for the purpose of collecting the plurality of statistics.

[0074] Optionally, the processing unit 201 receives at least some of the plurality of statistical values ​​from one or more of the plurality of processing units.

[0075] Optionally, the processing unit 201 identifies 301 the caller block and the target block according to a number of statistics.

[0076] The description of various embodiments is presented for illustrative purposes, but is not intended to be exhaustive or limited to the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments. The terms used in this specification are selected to best explain the principles of the embodiments, practical applications or technical improvements to the technology found in the market, or to enable those skilled in the art to understand the embodiments disclosed herein.

[0077] During the life of the patent which matures from this application, many related intermediate representations and computer architectures will be developed, and the scope of the terms "intermediate representation" and "computer architecture" is intended to include, a priori, all such new technologies.

[0078] As used herein, the term "about" means ±10%.

[0079] The terms "comprises," "comprising," "includes," "including," "having" and their cognates mean "including but not limited to." This term encompasses the terms "consisting of" and "consisting essentially of."

[0080] The phrase "consisting essentially of" means that the composition or method may include additional components and / or steps, but only if the additional components and / or steps do not materially alter the basic and novel characteristics of the claimed composition or method.

[0081] As used herein, the singular forms "a," "an," and "the" include plural referents unless the context clearly indicates otherwise. For example, the term "a compound" or "at least one compound" can include a plurality of compounds, including mixtures thereof.

[0082] The word "exemplary" is used herein to mean "serving as an example, instance, or illustration." Any embodiment described as "exemplary" is not necessarily to be construed as preferred or advantageous over other embodiments and / or to exclude the incorporation of features from other embodiments.

[0083] As used herein, the word "optionally" is used to mean "provided in some embodiments and not provided in other embodiments." Any particular embodiment may include more than one "optional" feature, unless such features are inconsistent.

[0084] Throughout this application, various embodiments may be presented in a range format. It should be understood that the description in range format is merely for convenience and brevity and should not be construed as an inflexible limitation on the scope of the embodiments. Thus, the description of a range should be considered to have specifically disclosed all possible subranges as well as individual numerical values ​​within that range. For example, description of a range such as "1 to 6" should be considered to have specifically disclosed subranges such as "1 to 3", "1 to 4", "1 to 5", "2 to 4", "2 to 6", "3 to 6", etc., and individual numerical values ​​within that range, e.g., 1, 2, 3, 4, 5, and 6. This applies regardless of the breadth of the range.

[0085] Whenever a numerical range is given herein, it is meant to include any recited numbers (fractional or integer) within the given range. The phrases "ranging / ranges between" a first designator number and a second designator number, and the phrases "ranging / ranges from" a first designator number "to" a second designator number, are used interchangeably herein and are meant to include the first designator number and the second designator number, and all fractional and integer numbers therebetween.

[0086] It is understood that certain features of an embodiment that are described for clarity in the context of separate embodiments can also be provided in combination in a single embodiment. Conversely, various features of an embodiment that are described for brevity in the context of a single embodiment can also be provided separately or in any suitable subcombination or as preferred in any other described embodiment. Particular features described in the context of various embodiments should not be considered essential features of those embodiments, unless the embodiment cannot function without those elements.

[0087] While the embodiment has been described in connection with specific embodiments thereof, it is evident that many alternatives, modifications, and variations will be apparent to those skilled in the art. Accordingly, it is intended to embrace all such alternatives, modifications, and variations that fall within the spirit and broad scope of the appended claims.

[0088] It is the intention of the applicants (applicants) that all publications, patents, and patent applications mentioned herein are incorporated herein by reference in their entirety, as if each individual publication, patent, or patent application was specifically and individually indicated to be incorporated herein by reference. Furthermore, citation or identification of any reference in this application should not be construed as an admission that such reference is available as prior art to the present invention. Section headings, if used, should not be construed as necessarily limiting. Additionally, any priority document(s) of this application are hereby incorporated herein by reference in their entirety.

Claims

1. An apparatus (200) for executing a software program (101), comprising: A plurality of processing units (210, 220) and at least one hardware processor (201), The at least one hardware processor: In an intermediate representation (102) of the software program comprising a plurality of blocks, each block being associated with one of a plurality of execution blocks of the software program and comprising an intermediate instruction set, identifying (301) a caller block (111) comprising at least one control flow intermediate instruction for executing at least one target side intermediate instruction of the target side block (121) and the target side block (121); generating (311) a target-side executable instruction set (122) using the target-side blocks; generating (313) said caller executable instruction set (122) using said caller block and using at least one computer control instruction for calling said target executable instruction set, if said caller executable instruction set is executed by a caller processing unit (210) of said plurality of processing units and said target executable instruction set is executed by a target processing unit (220) of said plurality of processing units; configuring (321) said caller processing unit to execute said caller executable instruction set; configuring the target processing unit to execute the target executable instruction set (323); The apparatus is adapted to

2. 2. The apparatus of claim 1, wherein the target processing unit is further configured to provide (410) at least one value produced by the target processing unit executing (402) at least some of the target executable instructions to the caller processing unit.

3. 3. The apparatus of claim 2, wherein the caller processing unit is further configured to receive (413) from the caller processing unit the at least one value produced by the target processing unit executing at least some of the target executable instruction set.

4. The apparatus of claim 1 , wherein the caller processing unit is further configured to provide (410) a value of at least one argument to the target processing unit.

5. 2. The apparatus of claim 1, wherein the target processing unit is further configured to instruct the caller processing unit to execute at least some of the caller executable instruction set after executing at least some other of the target executable instruction set.

6. The calling processing unit further comprises: suspending execution of the caller executable instruction set after executing the at least one computer control instruction for calling the target executable instruction set; Executing (422) the at least some of the caller executable instruction set in response to receiving instructions from the target processing unit. The apparatus of claim 5 , configured to:

7. 2. The apparatus of claim 1, wherein the target side processing unit is selected from the group of processing units consisting of a central processing unit, a multi-core central processing unit (CPU), a data processing unit (DPU), a microcontroller unit (MCU), an accelerated processing unit (ACU), a field programmable gate array (FPGA), a coarse-grained reconfigurable architecture (CGRA), a neural network accelerator, an intelligence processing unit (IPU), an application specific integrated circuit (ASIC), a quantum computer, and an interconnected computing grid comprising a plurality of reconfigurable logic elements connected by a plurality of configurable data routing junctions.

8. The apparatus of claim 1 , wherein a first computer architecture of the calling processing unit is different from a second computer architecture of the target processing unit.

9. 9. The apparatus of claim 8, wherein at least one of the first computer architecture and the second computer architecture is selected from the group of computer architectures consisting of a complex instruction set computer (CISC) architecture, a reduced instruction set computer (RISC) architecture, an x86 family-based computer architecture, an IBM (International Business Machine) Power family-based computer architecture, and an ARM family-based computer architecture.

10. 9. The apparatus of claim 8, wherein the caller executable instruction set comprises a plurality of conversion instructions implementing an application binary interface applied to the at least one control flow intermediate instruction to convert between the first computer architecture of the caller processing unit and the second computer architecture of the target processing unit.

11. the target-side block comprises a plurality of target-side metadata values; 10. The apparatus of claim 8, wherein generating the target executable instruction set comprises generating a plurality of target metadata values ​​transformed using the plurality of target metadata values ​​in accordance with the second computer architecture of the target processing unit.

12. the caller executable instruction set comprises at least one first memory access instruction to at least one memory address within an identified range of application memory addresses; The apparatus of claim 1 , wherein the target-side executable instruction set comprises at least one second memory access instruction to at least one other memory address within the identified range of application memory addresses.

13. 13. The apparatus of claim 12, wherein the identified range of application memory addresses is one of a physical memory address range, a virtual memory address range, a memory mapped I / O address range, and a bus address range.

14. the caller executable set of instructions comprises accessing at least one device using at least one device handle associated with the at least one device; The apparatus of claim 1 , wherein the target side executable instruction set comprises accessing the at least one device using the at least one device handle.

15. 15. The apparatus of claim 14, wherein the at least one device handle is at least one of a network socket handle, an operating system kernel object handle, and a file descriptor.

16. The at least one hardware processor: collecting (330) a plurality of statistics during execution of at least a portion of the software program; identifying the caller block and the target block according to the plurality of statistics (301); The apparatus of claim 1 further adapted to:

17. 20. The apparatus of claim 16, wherein at least one of the plurality of statistics is indicative of one of an outcome of executing a control flow instruction, a data value of a variable of the software program, a memory access pattern, and a memory virtual address translation.

18. The at least one hardware processor:

17. The apparatus of claim 16, further adapted to insert telemetry intermediate instructions into the intermediate representation of the software program for purposes of collecting the statistics.

19. The apparatus of claim 1 , wherein the calling processing unit is the at least one hardware processor.

20. A method (300) for executing a software program (101), comprising: Identifying (301) by at least one computer processor in an intermediate representation of the software program comprising a plurality of blocks, each block being associated with one of a plurality of execution blocks of the software program and comprising an intermediate instruction set, a caller block (111) comprising at least one control flow intermediate instruction causing at least one processing unit (210, 220) executing the target block to execute at least one target intermediate instruction of the target block, and the target block (121); generating (311) a target-side executable instruction set (112) using the target-side blocks by the at least one computer processing processor; generating (313), by said at least one computer processor, said caller executable instruction set (112) using said caller block and using at least one computer control instruction for calling said target executable instruction set, if said caller executable instruction set is executed by a caller processing unit (210) of a plurality of processing units (210, 220) and said target executable instruction set is executed by a target processing unit (220) of said plurality of processing units; configuring (321) the caller processing unit to execute, by the at least one computer processor, the caller executable instruction set; configuring (323) the target processing unit to execute, by the at least one computer processing processor, the target executable instruction set; A method comprising:

21. 1. A software program comprising: first program instructions in an intermediate representation of the software program comprising a plurality of blocks, each block being associated with one of a plurality of executable blocks of the software program and comprising a set of intermediate instructions, the first program instructions causing the at least one computer processor to identify a caller block and a target block, the caller block comprising at least one control flow intermediate instruction causing at least one processing unit executing the target block to execute at least one target intermediate instruction of the target block; second program instructions for causing the at least one computer processor to generate a target-side executable instruction set using the target-side blocks; third program instructions for causing the at least one computer processor to generate a caller executable instruction set using the caller block and using at least one computer control instruction for calling the target executable instruction set when the caller executable instruction set is executed by a caller processing unit of a plurality of processing units and the target executable instruction set is executed by a target processing unit of the plurality of processing units; fourth program instructions for causing the at least one computer processor to configure the calling processing unit to execute the calling executable instruction set; fifth program instructions for causing the at least one computer processor to configure the target processing unit to execute the target executable instruction set; A software program comprising:

Images