# US 2004/0083455 A1 · Method and apparatus for overlay management within an integrated executable for a heterogeneous architecture

> Agents: this data is available as JSON from the patentgrep API and MCP server — see https://patentgrep.com/llms.txt

- Number: US 2004/0083455 A1
- Document ID: US20040083455A1
- Status: Published application
- Kind: A1
- Application number: 10/280,242
- Filed: 2002-10-24
- Published: 2004-04-29
- Earliest claimed: 2002-10-24
- Assignees: International Business Machines Corporation
- Inventors: Michael Karl Gschwind; Kathryn M. O'Brien; John Kevin O'Brien; Valentina Salapura
- Web page: https://patentgrep.com/patent/US20040083455A1

## CPC

- G06F 8/453: {Data distribution}
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)

## 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

### Claim 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.

### Claim 2 (depends on 1)

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

### Claim 3 (depends on 1)

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.

### Claim 4 (depends on 1)

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

### Claim 5 (depends on 1)

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

### Claim 6 (depends on 3)

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

### Claim 7 (depends on 1)

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

### Claim 8 (depends on 1)

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.

### Claim 9 (depends on 1)

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

### Claim 10 (depends on 1)

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

### Claim 11 (depends on 1)

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

### Claim 12 (depends on 1)

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

### Claim 13 (depends on 1)

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.

### Claim 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.

### Claim 15 (depends on 14)

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

### Claim 16 (depends on 14)

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

### Claim 17 (depends on 14)

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

### Claim 18 (depends on 14)

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

### Claim 19 (depends on 14)

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

### Claim 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.

### Claim 21 (depends on 20)

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

### Claim 22 (depends on 20)

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.

### Claim 23 (depends on 20)

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

### Claim 24 (depends on 20)

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

### Claim 25 (depends on 20)

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

### Claim 26 (depends on 20)

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

### Claim 27 (depends on 20)

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

### Claim 28 (depends on 20)

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.

### Claim 29 (depends on 20)

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.

### Claim 30 (depends on 20)

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.

### Claim 31 (depends on 20)

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.

### Claim 32 (depends on 20)

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.

### Claim 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.

### Claim 34 (depends on 30)

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

### Claim 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.

### Claim 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.
