Method and apparatus for overlay management within an integrated executable for a heterogeneous architecture

• US 20040083455A1
• Filed: 10/24/2002
• Published: 04/29/2004
• Est. Priority Date: 10/24/2002
• Status: Active Grant

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: Gschwind, Michael Karl, Salapura, Valentina, OʼBrien, Kathryn M., OʼBrien, John Kevin
• Granted Patent: US 7,222,332 B2
• Time in Patent Office: Days
• US Class Current: 717/120
• CPC Class Codes: G06F 8/453 Data distribution

Abstract

The present invention provides for creating and employing code and data partitions in a heterogeneous environment. This is achieved by separating source code and data into at least two partitioned sections and at least one unpartitioned section. Generally, a partitioned section is targeted for execution on an independent memory device, such as an attached processor unit. Then, at least two overlay sections are generated from at least one partition section. The plurality of partition sections are pre-bound to each other. A root module is also created, associated with both the pre-bound plurality of partitions and the overlay sections. The root module is employable to exchange the at least two overlay sections between the first and second execution environments. The pre-bound plurality of partition sections are then bound to the at least one unpartitioned section. The binding produces an integrated executable.

Claims

1. A method for creating and employing overlays to operate in a heterogeneous Instruction Set Architecture, comprising:

separating information into at least two partitioned sections and at least one unpartitioned section;

targeting the at least one unpartitioned section to a first execution environment;

targeting a plurality of partitions to a second execution environment;

generating at least two overlay sections from at least one partition section;

binding the plurality of partition sections to each other;

creating a root module, associated with both the pre-bound plurality of partitions and the overlay sections, employable to exchange the at least two overlay sections between the first and second execution environments;

binding the pre-bound plurality of partition sections to the at least one unpartitioned section; and

creating an integrated executable.

2. The method of claim 1, wherein the step of binding further comprises resolving references of the pre-bound partitions.

3. The method of claim 1, further comprising employing the root module employable to swap the plurality of partitions between the first and second execution environment.

4. The method of claim 1, wherein the step of partitioning information further comprises partitioning code.

5. The method of claim 1, wherein the step of partitioning information further comprises partitioning data.

6. The method of claim 3, wherein the step of partitioning further comprises employing user-defined pragmas.

7. The method of claim 1, wherein the step of partitioning employs a compiler.

8. The method of claim 1, wherein the step of partitioning information further comprises generating a code partition employable to overlay a second code partition in the second execution environment.

9. The method of claim 1, wherein the binding further comprises inserting relocation information.

10. The method of claim 1, wherein the step of creating a root module occurs during a compilation.

11. The method of claim 1, wherein the step of creating a root module occurs after compilation.

12. The method of claim 1, wherein the step of creating a root module further comprises targeting the root module to an attached processor unit.

13. The method of claim 1, wherein the step of creating a root module further comprises inserting memory flow commands employable to affect a data transfer of the partitions between the first and second execution environments into the root module.

14. A method for generating and managing a root module in an attached processor unit of a heterogeneous computing environment, the method comprising:

creating two or more overlays from at least a part of two or more partitioned code sections;

creating the root module employable to control the execution of the two or more overlays in the attached processor unit, and the root module is further employable for execution in the attached processor unit;

identifying one or more common shared data components between the at least two or more overlays;

inserting a first set of relocation information associated with the one or more identified common shared data components into the root module, whereby the root module is employable to effect information transmissions between a system memory and the attached processor unit; and

inserting a second set of relocation information associated with the one or more identified common shared data components into the root module, whereby the root module is employable to identify and adjust the memory boundaries of the two or more overlays.

15. The method of claim 14, wherein the overlay comprises a code overlay.

16. The method of claim 14, wherein the overlay comprises a data overlay.

17. The method of claim 14, further comprising a step of partitioning code sections, wherein the partitioning occurs through the guidance of a programmer.

18. The method of claim 14, further comprising a step of partitioning code sections, wherein the partitioning occurs through an employment of a compiler.

19. The method of claim 14, further comprising creating an integrated executable.

20. A method for employing overlay management in a heterogeneous computing system, the method comprising:

transferring code from a first execution environment to a second execution environment;

transferring shared data from the first execution environment to the second execution environment;

processing the shared data in the second execution environment;

overlaying the code in the second execution environment with other code from the first execution environment, but not overlaying the shared data with other data from the first execution environment; and

processing the shared data in the second execution environment through employment of the overlaid new code.

21. The method of claim 20, wherein the step of transferring further comprising employing a memory address, wherein the memory address delimits the shared data.

22. The method of claim 20, wherein the step of transferring code from a first execution environment to a second execution environment employs a stub function.

23. The method of claim 20, further comprising transferring code from a main processor unit to a second execution environment.

24. The method of claim 20, further comprising transferring code from a first execution environment to an attached processor unit.

25. The method of claim 20, further comprising managing the overlaying of code through the employment of root module.

26. The method of claim 20, further comprising transferring non-shared data from a first execution environment to a second execution environment.

27. The method of claim 20, further comprising data processing the non-shared data.

28. The method of claim 20, further comprising overlaying the non-shared data in the second execution environment with other non-shared data from the first execution environment, but not overlaying the shared data with other data from the first execution environment.

29. The method of claim 20, further comprising modifying the shared data in the second execution environment by the code stored in the second execution environment.

30. The method of claim 20, wherein the step of processing the processed data in the second execution environment through employment of the overlaid new code comprises processing the shared data in a data pipeline.

31. The method of claim 20, wherein the shared data resides in the second execution unit for at least two loadings of a plurality of code.

32. The method of claim 20, wherein code comprising at least one library routine resides in the second execution environment for at least one overlaying of code.

34. The apparatus of claim 30, wherein the root module resides in the attached processor unit.

33. A system having an overlay root module in a heterogeneous computing environment, the system comprising:

a plurality of overlay sections;

a local store;

shared data, wherein the shared data is referenced by the plurality of overlay sections, and is stored in the local store;

at least one overlay data transmission command;

a system memory;

a memory flow controller, wherein the memory flow controller is employable to be commanded by the at least one overlay data transmission command to transfer the plurality of overlay sections between the system memory and the local store; and

the root module, wherein the overlay root module is employable to load the plurality of the overlay sections from the system memory into the local store without overwriting the shared data.

35. A computer program product for creating and employing overlays to operate in a heterogeneous Instruction Set Architecture, the computer program product having a medium with a computer program embodied thereon, the computer program comprising:

computer code for separating information into at least two partitioned sections and at least one unpartitioned section;

computer code for targeting the at least one unpartitioned section to a first execution environment;

computer code for targeting a plurality of partitions to a second execution environment;

computer code for generating at least two overlay sections from at least one partition section;

computer code for binding the plurality of partition sections to each other;

computer code for creating a root module, associated with both the pre-bound plurality of partitions and the overlay sections, employable to exchange the at least two overlay sections between the first and second execution environments;

computer code for binding the pre-bound plurality of partition sections to the at least one unpartitioned section; and

computer code for creating an integrated executable.

36. A processor for creating and employing overlays to operate in a heterogeneous Instruction Set Architecture, the processor including a computer program comprising:

computer code for separating information into at least two partitioned sections and at least one unpartitioned section;

computer code for targeting the at least one unpartitioned section to a first execution environment;

computer code for targeting a plurality of partitions to a second execution environment;

computer code for generating at least two overlay sections from at least one partition section;

computer code for binding the plurality of partition sections to each other;

computer code for creating a root module, associated with both the pre-bound plurality of partitions and the overlay sections, employable to exchange the at least two overlay sections between the first and second execution environments;

computer code for binding the pre-bound plurality of partition sections to the at least one unpartitioned section; and

computer code for creating an integrated executable.