Techniques for switching threads within routines

• US 10,007,551 B2
• Filed: 10/21/2013
• Issued: 06/26/2018
• Est. Priority Date: 10/25/2007
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Inventors: Cwalina, Krzysztof
• Primary Examiner(s): Swift, Charles M
• Application Number:
  US14/059,278
• Publication Number:
  US 20140047446A1
• Time in Patent Office: 1,709 Days
• Field of Search: None
• CPC Class Codes: G06F 9/4484 Executing subprograms
• CPC Class Codes: G06F 9/46 Multiprogramming arrangements
• CPC Class Codes: G06F 9/461 Saving or restoring of program or task context
• CPC Class Codes: G06F 9/48 Program initiating; Program switching, e.g. by interrupt
• CPC Class Codes: G06F 9/4806 Task transfer initiation or dispatching
• CPC Class Codes: G06F 9/4843 by program, e.g. task dispatcher, supervisor, operating system
• CPC Class Codes: G06F 9/485 Task life-cycle, e.g. stopping, restarting, resuming execution G06F9/4881 takes precedence
• CPC Class Codes: G06F 9/4856 resumption being on a different machine, e.g. task migration, virtual machine migration G06F9/5088 takes precedence
• CPC Class Codes: G06F 9/4881 Scheduling strategies for dispatcher, e.g. round robin, multi-level priority queues
• CPC Class Codes: G06F 9/50 Allocation of resources, e.g. of the central processing unit [CPU]
• CPC Class Codes: G06F 9/5005 to service a request
• CPC Class Codes: G06F 9/5011 the resources being hardware resources other than CPUs, Servers and Terminals
• CPC Class Codes: G06F 9/5022 Mechanisms to release resources
• CPC Class Codes: G06F 9/5027 the resource being a machine, e.g. CPUs, Servers, Terminals
• CPC Class Codes: G06F 9/5038 considering the execution order of a plurality of tasks, e.g. taking priority or time dependency constraints into consideration scheduling strategies G06F9/4881 and subgroups

Abstract

Various technologies and techniques are disclosed for switching threads within routines. A controller routine receives a request from an originating routine to execute a coroutine, and executes the coroutine on an initial thread. The controller routine receives a response back from the coroutine when the coroutine exits based upon a return statement. Upon return, the coroutine indicates a subsequent thread that the coroutine should be executed on when the coroutine is executed a subsequent time. The controller routine executes the coroutine the subsequent time on the subsequent thread. The coroutine picks up execution at a line of code following the return statement. Multiple return statements can be included in the coroutine, and the threads can be switched multiple times using this same approach. Graphical user interface logic and worker thread logic can be co-mingled into a single routine.

Claims

1. A method comprising:

executing an initial portion of a routine on an initial thread;

processing a first return statement that is a yield statement, the processing of the first return statement causing the routine to temporarily exit the routine at an end point of the initial portion;

identifying a subsequent thread different than the initial thread via a subsequent thread identifier included in the return statement, the return statement provided in response to the processing of the initial portion; and

performing a subsequent execution of the routine on the subsequent thread via the first return statement, the subsequent execution executing a subsequent portion of the routine from the end point of the initial portion.

2. The method of claim 1, further comprising receiving a request from an originating routine to execute the routine, wherein the executing of the initial portion of the routine is performed in response to the receiving of the request.

3. The method of claim 1, further comprising receiving a response from the routine after the executing of the initial portion of the routine, wherein the response identifies the subsequent thread.

4. The method of claim 3, further comprising executing the routine a plurality of times until an end of the routine is reached, wherein each execution of the routine is executed on a most recent subsequent thread indicated by the routine upon a most recent response from the routine.

5. The method of claim 3, further comprising specifying the subsequent thread as a parameter to the response.

6. The method of claim 1, further comprising selecting the subsequent thread from a threadpool.

7. The method of claim 1, further comprising using the subsequent thread to facilitate processing graphical user interface logic.

8. The method of claim 1, further comprising using the subsequent thread to facilitate processing worker thread logic.

9. A computer-readable memory storing instructions executable by a computing device to cause the computing device to perform operations comprising:

processing an initial portion of a routine on a first thread;

exiting the routine at an end point of the initial portion, the exiting caused by a processing of a first return statement that is a yield statement;

identifying a subsequent thread different than the first thread via a subsequent thread identifier included in the return statement, the return statement provided in response to the processing of the initial portion; and

performing a subsequent processing of the routine from the end point on the subsequent thread via the first return statement.

10. The computer-readable memory of claim 9, the operations further comprising determining the subsequent thread from a plurality of candidate threads included in a threadpool.

11. The computer-readable memory of claim 9, the operations further comprising specifying the subsequent thread via a parameter returned in response to the processing of the initial portion.

12. The computer-readable memory of claim 9, the operations further comprising implementing the routine as a coroutine.

13. The computer-readable memory of claim 9, the operations further comprising configuring the first thread to perform a different type of operation than the subsequent thread.

14. A system, comprising at least one processor coupled to at least one computer-readable storage medium storing instructions executable by the at least one processor to implement:

executing code corresponding to an initial portion of a routine on a first thread;

exiting the routine temporarily in response to a processing of a first return statement that is a yield statement; and

switching from an execution of the initial portion of the routine on the first thread to a subsequent execution of a subsequent portion of the routine on a second thread via the first return statement, the first thread different than the second thread, the switching comprising identifying the subsequent thread via a parameter included in the return statement, the return statement provided in response to the execution of the initial portion.

15. The system of claim 14, the switching further comprising selecting the subsequent thread from a threadpool.

16. The system of claim 14, the switching comprising performing a plurality of thread switches, each of the plurality of thread switches associated with a corresponding return statement identifying a respective subsequent thread.

17. The system of claim 14, the executing of the code corresponding to the initial portion of the routine performed in response to receiving a request from an originating routine to execute the routine.

18. The system of claim 14, the switching facilitating a co-mingling of graphical user interface logic and worker thread logic in the routine.