# US 9,436,474 B2 · Lock free streaming of executable code data

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

- Number: US 9,436,474 B2
- Document ID: US9436474B2
- Status: Granted
- Kind: B2
- Application number: 13/560,216
- Filed: 2012-07-27
- Published: 2014-01-30
- Granted: 2016-09-06
- Earliest claimed: 2012-07-27
- Assignees: Microsoft Technology Licensing, LLC
- Applicants: Kristofer Reierson
- Inventors: Kristofer Reierson
- Web page: https://patentgrep.com/patent/US9436474B2

## CPC

- G06F 9/3016: {Decoding the operand specifier, e.g. specifier format}
- G06F 9/30145: {Instruction analysis, e.g. decoding, instruction word fields}
- G06F 9/30149: {of variable length instructions}
- G06F 9/30181: {Instruction operation extension or modification}
- G06F 9/3802: {Instruction prefetching}
- G06F 9/3816: {Instruction alignment, e.g. cache line crossing}
- G06F 9/382: {Pipelined decoding, e.g. using predecoding}
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)

## Abstract

A disassembler receives instructions and disassembles them into a plurality of separate opcodes. The disassembler creates a table identifying boundaries between each opcode. Each opcode is written to memory in an opcode-by-opcode manner by atomically writing standard blocks of memory. Debug break point opcodes are appended to opcode to create a full block of memory when needed. The block of memory may be thirty-two or sixty-four bits long, for example. Long opcodes may overlap two or more memory blocks. Debug break point opcodes may be appended to a second portion of the long opcode to create a full block of memory. A stream fault interceptor identifies when a requested data page is not available and retrieving the data page.

## Claims

### Claim 1

A computer-implemented method, comprising:
receiving instructions comprising a plurality of opcodes, each opcode comprising one or more bytes of data;
disassembling the instructions into separate opcodes;
creating a table identifying the boundaries between each opcode;
appending debug break point opcodes to an opcode to create a full standard block of memory; and
writing each opcode to memory in an opcode-by-opcode manner by atomically writing standard blocks of memory.

### Claim 2 (depends on 1)

The computer-implemented method of claim 1, further comprising:
writing debug break point opcodes to all memory locations to initialize the memory.

### Claim 3 (depends on 1)

The computer-implemented method of claim 1, wherein the standard block of memory is thirty-two bits or sixty-four bits long.

### Claim 4 (depends on 1)

The computer-implemented method of claim 1, further comprising:
identifying when a long opcode will overlap two or more standard blocks of memory;
writing a second portion of the long opcode to a second memory block; and
writing a first portion of the long opcode to a first memory block.

### Claim 5 (depends on 4)

The computer-implemented method of claim 4, further comprising:
appending debug break point opcodes to the second portion of the long opcode to create a full standard block of memory.

### Claim 6 (depends on 5)

The computer-implemented method of claim 5, further comprising:
writing a previous opcode and the first portion of the long opcode to the first memory block.

### Claim 7

A computer system, comprising:
a processor;
system memory;
one or more computer-readable storage media having stored thereon computer-executable instructions that, when executed by the one or more processors, causes the processors to perform a method for streaming of executable code, the processor operating to:
receive instructions comprising a plurality of opcodes, each opcode comprising one or more bytes of data;
disassembling the instructions into separate opcodes;
creating a table identifying the boundaries between each opcode;
writing each opcode to memory in an opcode-by-opcode manner by atomically writing standard blocks of memory; and
append debug break point opcodes to an opcode to create a full standard block of memory.

### Claim 8 (depends on 7)

The computer system of claim 7, the processor further operating to:
writing debug break point opcodes to all memory locations to initialize the memory.

### Claim 9 (depends on 7)

The computer system of claim 7, wherein the standard block of memory is thirty-two bits or sixty-four bits long.

### Claim 10 (depends on 7)

The computer system of claim 7, the processor further operating to:
identify when a long opcode will overlap two or more standard blocks of memory;
write a second portion of the long opcode to a second memory block; and
write a first portion of the long opcode to a first memory block.

### Claim 11 (depends on 10)

The computer system of claim 10, the processor further operating to:
append debug break point opcodes to the second portion of the long opcode in to create a full standard block of memory.

### Claim 12 (depends on 10)

The computer system of claim 10, the processor further operating to:
write a previous opcode and the first portion of the long opcode to the first memory block.

### Claim 13 (depends on 7)

The computer system of claim 7, further comprising:
a stream fault interceptor operating to identify when a requested data page is not available; and
retrieving the data page from a remote source.

### Claim 14 (depends on 7)

The computer system of claim 7, further comprising:
a disassembler operating to disassemble the instructions into separate opcodes.

### Claim 15 (depends on 7)

The computer system of claim 7, further comprising:
a page tracker maintaining the table that identifies the boundaries between each opcode.

### Claim 16

A computer-readable storage medium that excludes propagated signals, said computer-readable storage medium storing computer-executable instructions that when executed by at least one processor cause the at least one processor to perform a method for streaming executable code data, the method comprising:
receiving a fault indicating that a data page is not available;
requesting instructions including the data page;
receiving the instructions from a remote source, the instructions comprising a plurality of opcodes, each opcode comprising one or more bytes of data;
disassembling the instructions into separate opcodes;
creating a table identifying the boundaries between each opcode;
identifying when a long opcode will overlap two or more standard blocks of memory;
writing each opcode to memory in an opcode-by-opcode manner by atomically writing standard blocks of memory;
writing a second portion of the long opcode to a second memory block; and
writing a first portion of the long opcode to a first memory block.

### Claim 17 (depends on 16)

The computer-readable storage medium of claim 16, wherein the method further comprises:
appending debug break point opcodes to an opcode to create a full standard block of memory.

### Claim 18 (depends on 16)

The computer-readable storage medium of claim 16, wherein the standard block of memory is thirty-two bits or sixty-four bits long.