# US 2009/0276576 A1 · Methods and Apparatus storing expanded width instructions in a VLIW memory for deferred execution

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

- Number: US 2009/0276576 A1
- Document ID: US20090276576A1
- Status: Published application
- Kind: A1
- Application number: 12/499,875
- Filed: 2009-07-09
- Published: 2009-11-05
- Earliest claimed: 2003-09-08
- Assignees: Altera Corporation
- Inventors: Gerald George Pechanek; Stamatis Vassiliadis
- Web page: https://patentgrep.com/patent/US20090276576A1

## CPC

- G06F 9/3802: {Instruction prefetching}
- G06F 9/38: Concurrent instruction execution, e.g. pipeline or look ahead
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)

## Abstract

Techniques are described for decoupling fetching of an instruction stored in a main program memory from earliest execution of the instruction. An indirect execution method and program instructions to support such execution arc addressed. In addition, an improved indirect deferred execution processor (DXP) VLIW architecture is described which supports a scalable array of memory centric processor elements that do not require local load and store units.

## Claims

### Claim 1

A method for decoupling fetching of an instruction stored in a main program memory from earliest execution of the instruction comprising:
partitioning a program into code segments to be executed by a processor;
establishing corresponding explicit execution instructions for each of the code segments;
fetching a particular code segment;
saving the particular code segment to a storage unit associated with the execution function; and
deferring execution of the particular code segment until initiation of execution is forced by the corresponding explicit execution instruction thereby decoupling execution of the code segments from their fetching.

### Claim 2 (depends on 1)

The method of claim 1 further comprising:
repeating the steps of fetching, saving and deferring for all the code segments; and
executing all the code segments in a partition comprising a plurality of processing elements as forced by the corresponding explicit execution instruction.

### Claim 3 (depends on 1)

The method of claim 1 further comprising:
preloading local cache storage prior to program execution by fetching a first plurality of instructions from a first code segment and saving the first fetched instructions to a memory serving as a cache for an execute engine; and
fetching a second plurality of instructions from a second code segment and saving those second fetched instruction to a separate location in the cache.

### Claim 4 (depends on 3)

The method of claim 3 further comprising:
executing both the first and second code segments in parallel upon encountering their respective explicit execution instructions.

### Claim 5

A system for decoupling fetching of an instruction stored in a main program memory from earliest execution of the instruction comprising:
means for partitioning a program into code segments to be executed by a processor:
means for fetching a particular code segment;
means for storing the particular code segment to a storage unit associated with an execution function;
means for establishing an explicit execution instruction corresponding to the particular code segment stored in the storage unit; and
means for deferring execution of the particular code segment until initiation of execution is forced by the corresponding explicit execution instruction thereby decoupling execution of the code segments from their fetching.

### Claim 6 (depends on 5)

The system of claim 5, wherein the means for partitioning comprises:
means for statically dividing the program into the code segments to be executed by the processor.

### Claim 7 (depends on 5)

The system of claim 5, wherein the corresponding explicit execution instruction contains address information that identifies an address in the storage unit associated with the particular code segment stored in the storage unit.

### Claim 8 (depends on 7)

The system of claim 7, wherein the initiation of execution is forced by fetching the particular code segment from the storage unit using the address information and executing the particular code segment on the execution function.

### Claim 9 (depends on 5)

The system of claim 5, wherein the means for fetching, the means for storing and the means for deferring operate for all the code segments, the system further comprising:
means for executing all the code segments in a partition comprising a plurality of processing elements as forced by the corresponding explicit execution instruction.

### Claim 10 (depends on 5)

The system of claim 5 further comprising:
means for preloading local cache storage prior to program execution by fetching a first plurality of instructions from a first code segment and saving those first fetched instructions to a memory serving as a cache for an execute engine; and
means for fetching a second plurality of instructions from a second code segment and saving those second fetched instructions to a separate location in the cache.

### Claim 11 (depends on 10)

The system of claim 10 further comprising:
means for executing both the first and second code segments in parallel upon encountering their respective explicit execution instructions.

### Claim 12

A method for parallel execution, the method comprising,
saving a segment of program code to a storage unit associated with execution functions;
storing program code without the segment of program code in an instruction memory separate from the storage unit;
inserting a deferred execution instruction in the program code at the point where the segment of program code is to be executed; and
fetching the deferred execution instruction from the instruction memory which initiates fetching the segment of program code from the storage unit to execute on the execution functions in parallel with other instructions fetched from the instruction memory.

### Claim 13 (depends on 12)

The method of claim 12, wherein the deferred execution instruction holds information that identifies the segment of program code to be executed.

### Claim 14 (depends on 12)

The method of claim 12, wherein the instruction memory is a global memory and the storage unit is a local memory in a processing element of a multiple processing element system.

### Claim 15 (depends on 12)

The method of claim 12, wherein the deferred execution instruction provides addressing information to an indirect execution mechanism to fetch the segment of program code from the storage unit for execution.

### Claim 16 (depends on 12)

The method of claim 12, wherein the execution functions comprises a fixed point function unit and a floating point function unit.

### Claim 17 (depends on 12)

The method of claim 12, wherein the saving a segment of program code to a storage unit is accomplished prior to the execution of the program code.

### Claim 18 (depends on 12)

The method of claim 12, wherein instructions from the program code and instructions from the segment of program code execute in parallel on a superscalar processor, wherein the parallel execution is controlled by the deferred execution instruction.

### Claim 19 (depends on 12)

The method of claim 12, further comprising:
generating an extended segment of program code by using extended instructions, wherein each of the extended instructions comprises a first number of bits, each instruction stored in the instruction memory comprising a second number of bits, wherein the first number of bits is greater than the second number of bits; and
saving the extended segment of program code to an extended storage unit associated with the execution functions and separate from the instruction memory holding the program code.

### Claim 20 (depends on 19)

The method of claim 19, further comprising:
inserting an extended deferred execution instruction in the program code at the point where the extended segment of program code is to be executed; and
fetching the extended deferred execution instruction from the instruction memory which initiates fetching the extended segment of program code from the storage unit to execute on the execution functions in parallel with other instructions fetched from the instruction memory.
