# US 2024/0231832 A1 · Scheduling of duplicate threads

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

- Number: US 2024/0231832 A1
- Document ID: US20240231832A1
- Status: Published application
- Kind: A1
- Application number: 18/391,470
- Filed: 2023-12-20
- Published: 2024-07-11
- Earliest claimed: 2022-12-21
- Assignees: Imagination Technologies Limited
- Applicants: Imagination Technologies Limited
- Inventors: Revanth Kamaraj; Vamshi Kadiyala; Jack Andrew; Ozgur Ozkurt
- Web page: https://patentgrep.com/patent/US20240231832A1

## CPC

- G06F 9/3836: {Instruction issuing, e.g. dynamic instruction scheduling or out of order instruction execution}
- G06F 9/5005: {to service a request}
- G06F 9/3009: {Thread control instructions}
- G06F 9/4812: {by interrupt, e.g. masked}
- G06F 9/4881: {Scheduling strategies for dispatcher, e.g. round robin, multi-level priority queues}
- G06F 9/505: {considering the load}
- G06F 9/5083: {Techniques for rebalancing the load in a distributed system}
- G06F 11/1497: Time redundant execution of software on a single processing unit
- G06F 11/1494: {N-modular type}
- G06F 11/1608: {Error detection by comparing the output signals of redundant hardware (G06F11/1629, G06F11/1666 take precedence; error detection or correction in information storage based on relative movement between record carrier and transducer G11B20/18; checking static stores for correct operation G11C29/00; for logic circuits H03K19/003, H03K19/007; for pulse counters or frequency dividers H03K21/40)}
- G06F 11/1629: {Error detection by comparing the output of redundant processing systems}
- G06F 11/1641: {where the comparison is not performed by the redundant processing components}
- G06F 2209/5018: Thread allocation
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)

## Abstract

A safety thread scheduler configured to schedule a check thread for a critical thread being run on one of a plurality of execution units, the check thread being a duplicate of the critical thread, wherein the safety thread scheduler is configured to schedule the check thread to begin being run on a second one of the plurality of execution units before the end of a safety time-window for scheduling the check thread. The safety thread scheduler is further configured to allow the check thread, when the check thread is running on the second one of the plurality of execution units, to be interrupted by a further thread and to re-schedule the check thread to be resumed by expiry of a re-scheduling time limit.

## Claims

### Claim 1

A safety thread scheduler configured to schedule a check thread for a critical thread being run on one of a plurality of execution units, the check thread being a duplicate of the critical thread;
the safety thread scheduler being configured to schedule the check thread to begin being run on a second one of the plurality of execution units before the end of a safety time-window for scheduling the check thread; and
the safety thread scheduler being further configured to allow the check thread, when the check thread is running on the second one of the plurality of execution units, to be interrupted by a further thread and to re-schedule the check thread to be resumed by expiry of a re-scheduling time limit.

### Claim 2 (depends on 1)

The safety thread scheduler of claim 1, configured to perform the re-scheduling of the check thread by interrupting another thread, other than the critical thread, running on one of the execution units other than the first execution unit, thereby resuming execution of the check thread on the execution unit upon which the other thread was running.

### Claim 3 (depends on 2)

The safety thread scheduler of claim 2, wherein the safety thread scheduler is operable such that the interrupted other thread is the further thread on the second execution unit, such that the check thread resumes on the second execution unit.

### Claim 4 (depends on 2)

The safety thread scheduler of claim 2, wherein the safety thread scheduler is operable such that the interrupted other thread is a thread, other than the critical thread and the further thread, running on a third one of the execution units other than the first and second execution units, such that the check thread is migrated to the third execution unit.

### Claim 5 (depends on 1)

The safety thread scheduler of claim 1, wherein the re-scheduling time limit is either:
a) the expiry of a safety time-window of a predetermined length running from a point at which the execution of the critical thread begins, or
b) the expiry of the safety time-window plus any time already spent executing the check thread, or
c) a time in between a) and b).

### Claim 6 (depends on 5)

The safety thread scheduler of claim 5, operable to initially schedule the check thread to begin executing, before the interruption by the further thread, any time between the point at which the execution of the critical thread begins and the expiry of the safety time-window.

### Claim 7 (depends on 6)

The safety thread scheduler of claim 6, configured to perform the initial scheduling of the check thread by:
i) if at least one of the execution units is detected to be idle by the point at which the execution of the critical thread begins, to select an idle one of the execution units as the second execution unit to begin the execution of the check thread; but
ii) if none of the execution units is detected to be idle by the point at which the execution of the critical thread begins, to wait and detect whether one becomes newly idle before the expiry of the safety time-window if so and thereupon select the newly idle execution unit as the second execution unit to begin the execution of the check thread; but
iii) if none of the execution units becomes idle by the expiry of the safety time-window, to interrupt a non-critical thread executing on a non-idle one of the execution units and select the non-idle execution unit as the second execution unit to begin the execution of the check thread.

### Claim 8 (depends on 7)

The safety thread scheduler of claim 7, configured to raise a panic condition if none of the execution units becomes idle nor is found to be executing a non-critical thread before the expiry of the safety time-window.

### Claim 9 (depends on 1)

The safety thread scheduler of claim 1, configured to perform the re-scheduling of the check thread by migrating the check thread to a third of said execution units other than the first and second execution units, resuming execution of the check thread on the third execution unit.

### Claim 10 (depends on 1)

The safety thread scheduler of claim 1, wherein the further thread is a thread other than a check thread.

### Claim 11 (depends on 1)

The safety thread scheduler of claim 1, wherein the further thread is a critical thread.

### Claim 12 (depends on 1)

The safety thread scheduler of claim 1, wherein the further thread is a non-critical thread.

### Claim 13 (depends on 1)

A processing system comprising the execution units and the safety thread scheduler as set forth in claim 1.

### Claim 14 (depends on 13)

The processing system of claim 13, further comprising comparison circuitry configured to compare a first result with a second result, the first result being a result of the execution of the critical thread on the first execution unit, and the second result being a result of the execution of the check thread on the second execution unit;
wherein the comparison circuitry is configured to raise error signal if the first and second results do not match according to said comparison.

### Claim 15 (depends on 14)

The processing system of claim 14, wherein the first result comprises an indication of memory accesses performed by the critical thread and the second result comprises an indication of memory accesses performed by the check thread.

### Claim 16 (depends on 14)

The processing system of claim 14, wherein the first and second results are output and compared in compressed form.

### Claim 17 (depends on 1)

A method of manufacturing, using an integrated circuit manufacturing system, a safety thread scheduler as set forth in claim 1, comprising inputting an integrated circuit dataset definition of said safety thread scheduler into an integrated circuit manufacturing system, so as to configure said integrated circuit manufacturing system to manufacture said safety thread scheduler.

### Claim 18

A computer readable storage medium having stored thereon a computer readable integrated circuit dataset description that, when processed in an integrated circuit manufacturing system, causes the integrated circuit manufacturing system to manufacture an integrated circuit embodying a safety thread scheduler configured to schedule a check thread for a critical thread being run on one of a plurality of execution units, the check thread being a duplicate of the critical thread;
the safety thread scheduler being configured to schedule the check thread to begin being run on a second one of the plurality of execution units before the end of a safety time-window for scheduling the check thread; and
the safety thread scheduler being further configured to allow the check thread, when the check thread is running on the second one of the plurality of execution units, to be interrupted by a further thread and to re-schedule the check thread to be resumed by expiry of a re-scheduling time limit.

### Claim 19 (depends on 1)

An integrated circuit manufacturing system configured to manufacture a safety thread scheduler as set forth in claim 1.

### Claim 20

A method comprising:
scheduling a check thread for a critical thread being run on one of a plurality of execution units, the check thread being a duplicate of the critical thread, wherein the scheduling of the check thread comprises scheduling the check thread to begin being run on a second one of the plurality of execution units before the end of a safety time-window for scheduling the check thread; and
when the check thread is running on the second one of the plurality of execution units, interrupting the check thread by a further thread and re-scheduling the check thread to be resumed by expiry of a re-scheduling time limit.
