Thread Weaving for Cross-Instruction Set Architecture Procedure Calls

The method simplifies code generation for heterogeneous multiprocessors by compiling, inserting RPCs, and renaming sections, addressing complexity and ensuring functional correctness across processors with different ISAs.

JP7592138B2Active Publication Date: 2024-11-29MAGIC LEAP INC
View PDF 2 Cites 0 Cited by

Patent Information

Application Number
JP2023183216
Authority / Receiving Office
JP · JP
Patent Type
Patents
Current Assignee / Owner
Priority Date
2018-07-10
Filing Date
2023-10-25
Publication Date
2024-11-29
Estimated Expiration
2039-07-10

AI Technical Summary

Technical Problem

Generating code for heterogeneous multiprocessors with different instruction set architectures is complex due to binary incompatibilities and separate procedure calls, making it difficult for programmers to ensure functional correctness using traditional high-level languages.

Method used

A method involving compiling applications on multiple processors with different ISAs, removing unnecessary functions, inserting remote procedure calls (RPCs) as proxies, and renaming sections to create a common application library, allowing seamless transitions between processors.

Benefits of technology

Enables efficient execution of applications across processors with different ISAs by simplifying code migration and ensuring functional correctness without rewriting, using traditional high-level threading primitives and libraries.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure 0007592138000002
    Figure 0007592138000002
  • Figure 0007592138000003
    Figure 0007592138000003
  • Figure 0007592138000004
    Figure 0007592138000004
Patent Text Reader

Abstract

To provide thread weave for cross-instruction set architecture procedure calls.SOLUTION: The present invention is directed to a method for storing an application having first to third functions. The first function, which is a main function that calls the second and third functions to run the application, compiles the application to first and second heterogeneous processors to create first and second CPU ISA objects respectively, prunes the first and second CPU ISA objects by removing the third function from the first CPU ISA objects and removing first and second functions from the second CPU ISA objects, proxy-inserts first and second RPCs in the first and second CPU ISA objects respectively to point respectively to the third function in the second CPU ISA objects and the second function in the first CPU ISA objects, and section-renames the second CPU ISA objects to common application library.SELECTED DRAWING: None
Need to check novelty before this filing date? Find Prior Art

Description

[Technical field]

[0001] (CROSS REFERENCE TO RELATED APPLICATIONS) This application claims priority from U.S. Provisional Patent Application No. 62 / 696,132, filed July 10, 2018, the entirety of which is incorporated herein by reference in its entirety.

[0002] 1. Background of the invention The present invention relates to a method for starting code, a method for executing an application, and a heterogeneous multiprocessor. [Background technology]

[0003] 2. Description of Related Technology Complex computer systems frequently utilize a heterogeneous approach with multiple processor cores from different vendors, each with a unique instruction set architecture. Generating code for a heterogeneous multiprocessor can be a difficult task for a programmer. The programmer must essentially deal with procedure calls that are separately compatible with two separate binary incompatible cores, and with procedure calls that may transition from one thread to another at the boundary where the other processor may be more efficient. This kind of complexity makes it difficult for software authors to focus on functional correctness using traditional high-level computer languages, such as high-level C++ threading primitives and libraries. Summary of the Invention [Means for solving the problem]

[0004] The present invention provides a method of initiating code, the method comprising: (i) storing an application in memory, the application having a first function, a second function, and a third function, the first function being a primary function that calls the second function and the third function to launch the application; (ii) compiling the application onto a first heterogeneous processor and a second heterogeneous processor to create a first central processing unit (CPU) instruction set architecture (ISA) object and a second CPU ISA object, respectively; (iii) pruning the first CPU ISA object and the second CPU ISA object by removing the third function from the first CPU ISA object and removing the first function and the second function from the second CPU ISA object; (iv) proxy-inserting a first remote procedure call (RPC) and a second RPC into the first CPU ISA object and the second CPU ISA object, respectively, to point to the third function in the second CPU ISA object and the second function in the first CPU ISA object, respectively; and (v) executing a second RPC on the first CPU ISA object and the second CPU ISA object. and section renaming the ISA objects to create a common application library of the first CPU ISA objects and the second CPU ISA objects.

[0005] The present invention also provides a computer readable medium having stored thereon a set of instructions executable by a processor to perform a method. The method includes: (i) storing an application in memory, the application having a first function, a second function, and a third function, the first function being a primary function that calls the second function and the third function to launch the first application; (ii) compiling the application onto a first heterogeneous processor and a second heterogeneous processor to create a first central processing unit (CPU) instruction set architecture (ISA) object and a second CPU ISA object, respectively; (iii) pruning the first CPU ISA object and the second CPU ISA object by removing the third function from the first CPU ISA object and removing the first function and the second function from the second CPU ISA object; (iv) proxy-inserting a first remote procedure call (RPC) and a second RPC into the first CPU ISA object and the second CPU ISA object, respectively, to point to the third function in the second CPU ISA object and the second function in the first CPU ISA object, respectively; and (v) performing a first RPC-insertion on the second CPU ISA object. and section renaming the ISA objects to create a common application library of the first CPU ISA object and the second CPU ISA object.

[0006] The present invention further provides a method for executing an application, the method including: (1) executing a first function of an application having a first function, a second function, and a third function, the first function being a primary function on a first processor with at least one of a first central processing unit (CPU) instruction set architecture (ISA) objects compiled into the first processor, the primary function causing sequential execution of (2) a first remote procedure call (RPC) on the first processor with at least one of the first CPU ISA objects, (3) a third function on a second processor with at least one of the second CPU ISA objects compiled into the second processor, (4) a second RPC on the second processor with at least one of the second CPU ISA objects, and (5) a second function on the first processor with at least one of the first CPU ISA objects.

[0007] The present invention also provides a heterogeneous multiprocessor, the heterogeneous multiprocessor including a first heterogeneous processor and a second heterogeneous processor, a memory, and an application on the memory, the application including a first function, a second function, and a third function, and a first remote procedure call (RPC) and a second RPC, (1) the first function is a primary function executed on the first processor with at least one of a first central processing unit (CPU) instruction set architecture (ISA) object compiled into the first processor, the primary function causes sequential execution of (2) the first RPC on the first processor with at least one of the first CPU ISA objects, (3) the third function on the second processor with at least one of the second CPU ISA objects compiled into the second processor, (4) the second RPC on the second processor with at least one of the second CPU ISA objects, and (5) the second function on the first processor with at least one of the first CPU ISA objects. The present specification also provides, for example, the following items: (Item 1) 1. A method of initiating code, comprising: (i) storing an application in a memory, the application having a first function, a second function, and a third function, the first function being a primary function that calls the second function and the third function to launch the application; (ii) compiling the application onto a first heterogeneous processor and a second heterogeneous processor to create a first central processing unit (CPU) instruction set architecture (ISA) object and a second CPU ISA object, respectively; (iii) pruning the first CPU ISA object and the second CPU ISA object by removing the third feature from the first CPU ISA object and removing the first feature and the second feature from the second CPU ISA object; (iv) proxy-inserting a first remote procedure call (RPC) and a second RPC into the first CPU ISA object and the second CPU ISA object, respectively, to point to the third function in the second CPU ISA object and the second function in the first CPU ISA object, respectively; (v) section renaming the second CPU ISA object to create a common application library for the first CPU ISA object and the second CPU ISA object; A method comprising: (Item 2) 2. The method of claim 1, wherein the first function points to the second function. (Item 3) 2. The method of claim 1, wherein the first function points to the first RPC. (Item 4) 2. The method of claim 1, further comprising replacing the third function in the first CPU ISA object and the second function in the second CPU ISA object with the first RPC and the second RPC, respectively. (Item 5) 2. The method of claim 1, wherein the application has data structures used by functions of the first CPU ISA object and the second CPU ISA object. (Item 6) 6. The method of claim 5, wherein during the compiling (ii), the data structure is compiled into the second processor. (Item 7) 7. The method of claim 6, wherein during the pruning (iii), the data structures are removed from the second CPU ISA object. (Item 8) 6. The method of claim 5, wherein the first function uses the data structure. (Item 9) 6. The method of claim 5, wherein the third function uses the data structure. (Item 10) 10. The method of claim 9, wherein the third function in the second CPU ISA object points to the data structure in the first CPU ISA object. (Item 11) (1) executing the primary function on the first processor with at least one of the first CPU ISA objects, the primary function comprising: (2) the first RPC on the first processor involving at least one of the first CPU ISA objects; (3) the third function on the second processor involving at least one of the second CPU ISA objects; (4) the second RPC on the second processor involving at least one of the second CPU ISA objects; and (5) the second function on the first processor involving at least one of the first CPU ISA objects. causing successive execution of The method according to item 4, further comprising: (Item 12) A computer-readable medium having stored thereon a set of instructions executable by a processor to perform a method, the method comprising: (i) storing an application in a memory, the application having a first function, a second function, and a third function, the first function being a primary function that calls the second function and the third function to launch the first application; (ii) compiling the application onto a first heterogeneous processor and a second heterogeneous processor to create a first central processing unit (CPU) instruction set architecture (ISA) object and a second CPU ISA object, respectively; (iii) pruning the first CPU ISA object and the second CPU ISA object by removing the third feature from the first CPU ISA object and removing the first feature and the second feature from the second CPU ISA object; (iv) proxy-inserting a first remote procedure call (RPC) and a second RPC into the first CPU ISA object and the second CPU ISA object, respectively, to point to the third function in the second CPU ISA object and the second function in the first CPU ISA object, respectively; (v) section renaming the second CPU ISA object to create a common application library for the first CPU ISA object and the second CPU ISA object; 13. A computer readable medium comprising: (Item 13) 1. A method of executing an application, comprising: (1) executing a first function of an application having a first function, a second function, and a third function, the first function being a primary function on the first processor with at least one of a first central processing unit (CPU) instruction set architecture (ISA) object being compiled into the first processor, the primary function being: (2) a first remote procedure call (RPC) on the first processor involving at least one of the first CPU ISA objects; (3) the third function on the second processor with at least one of the second CPU ISA objects being compiled into the second processor; (4) the second RPC on the second processor involving at least one of the second CPU ISA objects; and (5) the second function on the first processor involving at least one of the first CPU ISA objects. causing successive execution of A method comprising: (Item 14) 1. A heterogeneous multiprocessor, comprising: a first heterogeneous processor and a second heterogeneous processor; Memory, An application on the memory; Equipped with The application may include a first function, a second function, and a third function, and a first remote procedure call and a second remote procedure call (RPC); (1) the first function is a primary function that executes on the first processor involving at least one of a first central processing unit (CPU) instruction set architecture (ISA) object that is compiled into the first processor, the primary function comprising: (2) the first RPC on the first processor involving at least one of the first CPU ISA objects; (3) the third function on the second processor with at least one of the second CPU ISA objects being compiled into the second processor; (4) the second RPC on the second processor involving at least one of the second CPU ISA objects; and (5) the second function on the first processor involving at least one of the first CPU ISA objects. A heterogeneous multiprocessor that causes sequential execution of [Brief description of the drawings]

[0008] The invention will now be further explained, by way of example only, with reference to the accompanying drawings, in which:

[0009] [Figure 1] FIG. 1 is a block diagram illustrating a conceptual heterogeneous multiprocessor application.

[0010] [Diagram 2] 2-6 are block diagrams illustrating the development of heterogeneous multiprocessor applications. [Diagram 3] 2-6 are block diagrams illustrating the development of heterogeneous multiprocessor applications. [Figure 4] 2-6 are block diagrams illustrating the development of heterogeneous multiprocessor applications. [Diagram 5] 2-6 are block diagrams illustrating the development of heterogeneous multiprocessor applications. [Figure 6] 2-6 are block diagrams illustrating the development of heterogeneous multiprocessor applications.

[0011] [Figure 7] 7-11 illustrate run-time execution of a heterogeneous multiprocessor. [Figure 8] 7-11 illustrate run-time execution of a heterogeneous multiprocessor. [Figure 9] 7-11 illustrate run-time execution of a heterogeneous multiprocessor. [Figure 10] 7-11 illustrate run-time execution of a heterogeneous multiprocessor. [Figure 11] 7-11 illustrate run-time execution of a heterogeneous multiprocessor.

[0012] [Figure 12] FIG. 12 is a block diagram of a machine in the form of a computer capable of hosting a build system for deploying heterogeneous multiprocessor applications. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0013] Detailed Description of the Invention FIG. 1 illustrates a conceptual heterogeneous multiprocessor application 10 that includes code 12 for running on a primary instruction set architecture (ISA), code 14 for running on a secondary ISA, and common data 16.

[0014] The code 14 includes a first function 18 and a second function 20. The first function 18 is the primary function, which is the first function executed to launch the heterogeneous multiprocessor application 10. The code 14 includes a third function 22. The common data 16 includes a data structure 24. The first function 18 points to the second function 20 at 26 and points to the third function 22 at 28. The third function 22 points to the second function 20 at 30. The first function 18 and the third function 22 rely on the data structure 24 at 32 and 34, respectively.

[0015] It should be understood that an application may have more than three functions. For purposes of discussion, the heterogeneous multiprocessor structure is described as having only three functions, which is sufficient to explain the invention and does not include unnecessary clutter that may obscure the invention. However, additional functions may be included before, between, and / or after the three functions used in this description, and may call any other function in the present system belonging to any ISA via the same method.

[0016] FIG. 2 illustrates a first operation for creating a heterogeneous multiprocessor application 40 according to an embodiment of the present invention. The application is written in source code and stored in memory. The application is then compiled into a first heterogeneous multiprocessor and a second heterogeneous multiprocessor, creating a first central processing unit (CPU) ISA object 42A and a second CPU ISA object 42B, respectively. The processors have different ISAs and therefore rely on different objects for their functionality. The CPU ISA objects 42A and 42B therefore differ from each other according to the different requirements of the ISAs of the different processors. The CPU ISA objects 42A and 42B are compiled from the same source code and therefore have the same functional blocks. For example, the CPU ISA object 42A includes a first function 18A, and the CPU ISA object 42B also includes a first function 18B. The functional components of the CPU ISA objects 42A and 42B are identical to the functional components of the conceptual heterogeneous multiprocessor application 10 described with reference to FIG. 1. The components of the first CPU ISA object 42A and the links therebetween have the same reference numbers as the components of the conceptual heterogeneous multiprocessor application 10 in Figure 1, except that the first CPU ISA object 42A and their links are numbered with an "A" suffix (e.g., "20" to "20A"). Similarly, the components of the second CPU ISA object 42B are the same as the components of the heterogeneous multiprocessor application 10 in Figure 1, except that they are numbered with a "B" suffix (e.g., "20" to "20B").

[0017] FIG. 3 illustrates a pruning operation performed to build a heterogeneous multiprocessor application 40. In the first CPU ISA object 42A, the code 14A and the third function 22A are removed. The removal of the third function 22A also removes the link 34A to the data structure 24A. In the second CPU ISA object 42B, the code 12B for running on the secondary ISA is removed along with the first function 18B and the second function 20B. The common data 16B and the data structure 24B are also removed from the second CPU ISA object 42B. The removal of components from the second CPU ISA object 42B also severs the links at 26B, 28B, and 32B. The code 12A for running on the primary ISA has a ".text" naming structure, referred to as a "linker input section", ".text section", or "object file section". The code 14B for running on the secondary ISA has a ".text.isab" naming structure.

[0018] 4 illustrates a proxy insertion operation performed in the structure of a heterogeneous multiprocessor application 40. A first proxy section 46 and a second proxy section 48 are inserted into a first CPU ISA object 42A and a second CPU ISA object 42B, respectively. The first proxy section 46 includes a first remote procedure call (RPC) 50. A first function 18A points to the first RPC 50. The first RPC 50 points at 52 to a third function 22B of the second CPU ISA object 42B. In practice, the third function 22A in FIG. 2 can be replaced with the first RPC 50 in FIG. 4.

[0019] The second proxy section 48 includes a second remote procedure call (RPC) 54. The third function 22B points to the second RPC 54 at 30B. The second RPC 54 points to the second function 20A in FIG. 4 at 56. The second proxy section 48 has not been renamed at this point, and the link 56 is therefore not active. However, the link 56 is included in FIG. 4 to illustrate the final functionality of the heterogeneous multiprocessor application 40 after the second proxy section 48 has been renamed. Similarly, the link 34B is shown pointing to a data structure 24A to illustrate the final functionality of the heterogeneous multiprocessor application 40 after the code 14B for running on the secondary ISA has been renamed.

[0020] Figure 5 illustrates the section renaming operations performed to build a heterogeneous multiprocessor application 40. The code for running on the secondary ISA 14B and the second proxy section 48 are renamed from ".text.isab" to ".text" to match the naming of the first CPU ISA object 42A. Figure 6 illustrates the final links in the application library after the section renaming in Figure 5. The section renaming creates a generic ".text" section 60 containing the first function 18A, the second function 20A, and the third function 22B, and the first RPC 50 and the second RPC 54.

[0021] The source code may be written, for example, in C++ code, and then processing threads, such as those represented by the first function 18A, the second function 20A, and the third function 24A in FIG. 2, invisibly transition from one binary-incompatible core to another at procedure-invoked boundaries in what may be referred to as a "weaving" event. A software author may first focus on functional correctness using traditional high-level C++ thread primitives and libraries, and then, in a modular manner, migrate individual blocks of code to a more efficient processor without having to rewrite the code or rely on a different set of libraries. A system may have, for example, a digital signal processor (DSP) and a general-purpose central processing unit (CPU). From the software author's perspective, to launch a function on the DSP, all that needs to be done may be to add an attribute tag to a function specifying that it is placed in a specific non-".text" program section, as follows: [ka]

[0022] In the above example, after compiling the source file, the resulting object file may contain a function "foo" in the ".text_dsp" section. The build system will recognize and remove the ".text_dsp" section from the object file, then recompile the source file for the DSP's ISA. Any references to the "foo" function will be replaced with a shim function to initiate a remote procedure call on the DSP. In a similar manner, the reverse happens with respect to the DSP object file, any functions in the .text are removed, and any references to them in functions in the .text_dsp section are replaced with a shim function to initiate a remote procedure call back on the CPU. As long as the two processors have the same compiled structural layout, the same view into the same virtual memory, and have coherent caches at the time of the weaving event, the application should be able to seamlessly transition from one processor architecture to the other while maintaining a simple and coherent programmer view of the flow of execution.

[0023] FIG. 7 illustrates a first operation performed during runtime execution. A heterogeneous multiprocessor 70 has a main memory 72 that stores the components of the heterogeneous multiprocessor application 40 of FIG. 6. A first function 18A is a main function executed to launch the application. Block 74 indicates that the first function 18A executes on a first processor using a first CPU ISA object. Block 76 indicates that a second processor using a second CPU ISA object is idle. The first function 18A relies on a data structure 24A at 32A, for example, for purposes of looking up data. The first function 18A executes a second function 20A and a first RPC 50 at 26A and 26B.

[0024] 8 illustrates a second process executing on a heterogeneous multiprocessor 70 when a first function 18A starts a first RPC 50. Block 78 shows that the first RPC 50 executes on a first CPU using a first ISA object. Block 78 shows that the second CPU is still idle. The first RPC 50 executes at 52 a third function 22B.

[0025] 9 illustrates a third operation executed on the heterogeneous multiprocessor 70 when the first RPC 50 initiates the third function 22B. Block 80 indicates that the first CPU using the first ISA object is suspended. Block 82 indicates that the third function 22B executes with the second CPU using the second ISA object. The third function 22B utilizes the data structure 24A, e.g., for purposes of performing a lookup, at 34B. The third function 22B executes the second RPC 54, at 30B.

[0026] 10 illustrates a fourth operation performed on the heterogeneous multiprocessor 70 when the second RPC 54 executes. Block 80 indicates that the first CPU is still suspended. Block 84 indicates that the second RPC 54 executes with the second CPU using a second ISA object. The second RPC 54 executes at 56 the second function 20A.

[0027] 11 illustrates a fifth operation performed on the heterogeneous multiprocessor 70 when the second function 20A is executed. Block 86 indicates that the first function 20A is executed with the first CPU using the first ISA object. Block 88 indicates that the second CPU is suspended.

[0028] 12 illustrates a diagrammatic representation of a machine in the exemplary form of a computer system 900 within which a set of instructions may be executed to cause the machine to perform any one or more of the methodologies discussed herein. In alternative embodiments, the machine may operate as a stand-alone device or may be connected (e.g., networked) to other machines. Moreover, although only a single machine is illustrated, the term "machine" shall also be interpreted to include any collection of machines that individually or jointly execute a set (or multiple sets) of instructions to perform any one or more of the methodologies discussed herein.

[0029] The exemplary computer system 900 includes a processor 902 (e.g., a central processing unit (CPU), a graphics processing unit (GPU), or both), which communicate with each other via a bus 908, a main memory 904 (e.g., read only memory (ROM), flash memory, dynamic random access memory (DRAM) (e.g., synchronous DRAM (SDRAM) or Rambus DRAM (RDRAM)), etc.), and a static memory 906 (e.g., flash memory, static random access memory (SRAM), etc.).

[0030] The computer system 900 may further include a disk drive unit 916 and a network interface device 920 .

[0031] The disk drive unit 916 includes a machine-readable medium 922 on which is stored one or more sets of instructions 924 (e.g., software) that embody any one or more of the methodologies or functions described herein. The software may also reside, completely or at least partially, within the primary memory 904 and / or within the processor 902 during its execution by the computer system 900, with the primary memory 904 and the processor 902 also constituting machine-readable media.

[0032] The software may also be transmitted or received over a network 928 via the network interface device 920 .

[0033] Although the machine-readable medium 922 is shown in the exemplary embodiment to be a single medium, the term "machine-readable medium" should be interpreted to include a single medium or multiple media (e.g., a centralized or distributed database, and / or associated caches and servers) that store one or more sets of instructions. The term "machine-readable medium" should also be interpreted to include any medium capable of storing, encoding, or carrying a set of instructions for execution by a machine, causing the machine to perform any one or more of the methodologies of the present invention. The term "machine-readable medium" should thus be interpreted to include, but is not limited to, solid-state memories, optical and magnetic media, and carrier wave signals.

[0034] While certain exemplary embodiments have been described and illustrated in the accompanying drawings, it is to be understood that such embodiments are merely illustrative of the invention and not a limitation of the invention, and that the invention is not limited to the specific construction and arrangements shown and described, since modifications may occur to those skilled in the art.

Claims

1. A method for executing an application, comprising: (1) executing a first function of an application having a first function, a second function, and a third function, the first function being a primary function on the first processor with at least one of a first central processing unit (CPU) instruction set architecture (ISA) object being compiled into the first processor, the primary function comprising: (2) a first remote proxy call (RPC) on the first processor involving at least one of the first CPU ISA objects; (3) the third function on the second processor with at least one of the second CPU ISA objects being compiled into the second processor; (4) the second RPC on the second processor involving at least one of the second CPU ISA objects; and (5) the second function on the first processor involving at least one of the first CPU ISA objects. causing successive execution of Including, The method of claim 1, wherein the application has a data section used by functions of the first CPU ISA object and the second CPU ISA object.

2. The method of claim 1, wherein the first function points to the second function.

3. The method of claim 1, wherein the first function points to the first RPC.

4. The method of claim 1, wherein the first function uses the data section.

5. The method of claim 1, wherein the third function uses the data section.

6. A computer-readable medium having stored thereon a set of instructions executable by a processor to perform a method, the method comprising: (1) executing a first function of an application having a first function, a second function, and a third function, the first function being a primary function on the first processor with at least one of a first central processing unit (CPU) instruction set architecture (ISA) object being compiled into the first processor, the primary function comprising: (2) a first remote proxy call (RPC) on the first processor involving at least one of the first CPU ISA objects; (3) the third function on the second processor with at least one of the second CPU ISA objects being compiled into the second processor; (4) the second RPC on the second processor involving at least one of the second CPU ISA objects; and (5) the second function on the first processor involving at least one of the first CPU ISA objects. causing successive execution of Including, The application has data sections used by functions of the first CPU ISA object and the second CPU ISA object.

7. The computer-readable medium of claim 6, wherein the first function points to the second function.

8. The computer-readable medium of claim 6, wherein the first function points to the first RPC.

9. The computer-readable medium of claim 6, wherein the first function uses the data section.

10. The computer-readable medium of claim 6, wherein the third function uses the data section.

11. A heterogeneous multiprocessor, comprising: first and second heterogeneous processors; Memory, An application on the memory; Equipped with The application may include a first function, a second function, and a third function, and a first remote proxy call (RPC) and a second RPC; (1) the first function is a primary function that executes on the first processor involving at least one of a first central processing unit (CPU) instruction set architecture (ISA) object that is compiled into the first processor, the primary function comprising: (2) the first RPC on the first processor involving at least one of the first CPU ISA objects; (3) the third function on the second processor with at least one of the second CPU ISA objects being compiled into the second processor; (4) the second RPC on the second processor involving at least one of the second CPU ISA objects; and (5) the second function on the first processor involving at least one of the first CPU ISA objects. causes successive execution of The application has a data section that is used by functions of the first CPU ISA object and the second CPU ISA object.

12. The heterogeneous multiprocessor of claim 11, wherein the first function points to the second function.

13. The heterogeneous multiprocessor of claim 11, wherein the first function points to the first RPC.

14. The heterogeneous multiprocessor of claim 11, wherein the first function uses the data section.

15. The heterogeneous multiprocessor of claim 11, wherein the third function uses the data section.

Citation Information

Patent Citations

  • Two way communication support for heterogenous processors of a computer platform

    US20130061240A1

  • Compilation of application into multiple instruction sets for a heterogeneous processor

    WO2015143641A1