Techniques for switching threads within routines

• US 20090113436A1
• Filed: 10/25/2007
• Published: 04/30/2009
• Est. Priority Date: 10/25/2007
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Cwalina, Krzysztof
• Granted Patent: US 8,589,925 B2
• Time in Patent Office: Days
• US Class Current: 718/102
• 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 computer-readable medium having computer-executable instructions for causing a computer to perform steps comprising:

receiving a request from an originating routine to execute a coroutine;

executing the coroutine on an initial thread;

receiving a response back from the coroutine when the coroutine returns based upon a return statement; and

executing the coroutine a subsequent time on a subsequent thread that was indicated by the coroutine upon return.

2. The computer-readable medium of claim 1, further having computer-executable instructions for causing a computer to perform steps comprising:

executing the coroutine a plurality of times until an end of the coroutine is reached, each time executing the coroutine on a most recent subsequent thread indicated by the coroutine upon a most recent return.

3. The computer-readable medium of claim 1, wherein the subsequent thread is contained as a parameter to the return statement.

4. The computer-readable medium of claim 1, wherein the subsequent thread is used for processing worker thread logic.

5. A method for switching threads partially through a routine comprising the steps of:

starting an execution of a routine on a first thread;

exiting the routine at a point partially through the routine due to a first return statement, with the first return statement having a subsequent thread identifier;

resuming code execution of the routine on a subsequent thread specified in the subsequent thread identifier; and

picking up code execution in the routine at a line of code following the first return statement.

6. The method of claim 5, wherein at least one of the first thread and the subsequent thread is a thread used for processing graphical user interface logic.

7. The method of claim 5, wherein at least one of the first thread and the subsequent thread is a worker thread used for processing worker logic.

8. The method of claim 5, wherein the routine is a coroutine.

9. The method of claim 8, wherein the first thread is used to handle a different type of operation than the second thread.

10. The method of claim 5, wherein the subsequent thread identifier is contained as a parameter in the return statement.

11. The method of claim 5, further comprising:

repeating the exiting, resuming, and picking up steps a plurality of times until an end of the routine is reached.

12. The method of claim 5, wherein a first line of code contained in the routine is the first return statement.

13. The method of claim 12, wherein the first return statement is located at the first line of code so that a first desired thread for execution can be specified in the subsequent thread identifier before further code in the routine is processed.

14. A method for co-mingling graphical user interface logic and worker thread logic in a single routine comprising the steps of:

starting code execution of initial logic contained in a coroutine, the initial logic being executed on a first thread to receive user input;

receiving the user input;

exiting the coroutine partially through to switch to a second thread, the second thread being a different thread than the first thread; and

resuming code execution in the coroutine on the second thread to perform work in response to the user input.

15. The method of claim 14, wherein the exiting step is performed when a return statement is reached.

16. The method of claim 15, wherein the return statement contains a thread identifier as a parameter to specify a next thread that execution should be resumed on.

17. The method of claim 16, wherein a plurality of return statements are contained in the routine to indicate when thread switching should occur.

18. The method of claim 14, wherein the coroutine is called a plurality of times by a controller routine that is responsible for calling the coroutine on a proper thread.

19. The method of claim 18, wherein the controller routine is called by an originating routine.

20. The method of claim 19, wherein the originating routine contains a request to call the coroutine.