ASYNCHRONOUS EXECUTION FLOW

• US 20140053157A1
• Filed: 08/16/2012
• Published: 02/20/2014
• Est. Priority Date: 08/16/2012
• Status: Abandoned Application

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Parameshwar, Suresh, Zhao, Xiaoxuan
• Application Number:
  US13/586,885
• Publication Number:
  US 20140053157A1
• Time in Patent Office: Days
• US Class Current: 718/100
• CPC Class Codes: G06F 9/485 Task life-cycle, e.g. stopping, restarting, resuming execution G06F9/4881 takes precedence

Abstract

Tasks can be developed and maintained with synchronous code while concurrently being asynchronously executed, e.g., during time consuming operations. The tasks need not include asynchronous flow callbacks within the task framework. The callbacks can be transparently incorporated within the execution flow utilizing a callback wrapper(s) which transparently maintains and manages the necessary callbacks for asynchronous execution of the tasks. Thus a generic solution can be easily and effectively implemented for, e.g., production/request work item processing, that can be applied to both backend services and/or client software.

Claims

1. A method for developing a task that, when the task is executed comprises asynchronous logic flow execution, the method comprising:

developing sequential code for a task comprising task code, wherein the task code is defined at a first time t1 to comprise a first concurrency of at least one task instance, wherein the execution of a concurrency of the task code comprising a task instance is performed with a processing thread assigned to the task instance sequentially for a first time period tp1, and wherein during execution of the task instance the executing task instance invokes the execution of at least one time consuming operation that causes the task instance to thereafter be managed asynchronously for a second time period tp2 that is subsequent to the first time period tp1 and is the time period wherein the time consuming operation is performed; and

developing a callback wrapper, wherein the callback wrapper comprises a callback to a task instance and wherein the callback wrapper is executed for the task instance when the task instance can resume sequential processing for a third time period tp3 that is subsequent to the execution of the time consuming operation during the second time period tp2.

2. The method for developing a task of claim 1, wherein the task code comprises the capability to be redefined at a second time t2 to comprise a second concurrency of at least one task instance, wherein the second concurrency is different than the first concurrency.

3. The method for developing a task of claim 1, wherein the callback wrapper comprises at least one callback queue, and the callback wrapper further comprises the capability to suspend the execution of a task instance that has invoked a time consuming operation by managing the release of the processing thread associated with the task instance and queuing the task instance to a callback queue until the time consuming operation invoked by the task instance has terminated processing at the termination of the second time period tp2.

4. The method for developing a task of claim 1, wherein the task code comprises a code line comprising a return point that a callback from the callback wrapper will return sequential code execution control to at the start of the time period tp3 when the task instance can resume sequential processing, wherein the code line comprising the return point is sequentially after the invocation by the task of a time consuming operation.

5. The method for developing a task of claim 4, wherein the code line comprising a return point comprises a yield return call for the task.

6. The method for developing a task of claim 5, wherein a pre-established enumerator methodology utilized by the operating system executing at least one task instance is utilized by the callback wrapper to manage concurrent asynchronous execution processing of at least two task instances.

7. An asynchronous logic flow execution method for a consumer-producer model comprising at least one consumer task comprising at least one instance, at least one producer task comprising at least one instance, a shared queue for storing items produced by the producer task and retrieved for consumption by the consumer task, a callback queue for a consumer task comprising a consumer callback queue, and a callback queue for a producer task comprising a producer callback queue, the asynchronous logic flow execution method comprising:

initiating the execution of a consumer task instance that invokes an operation for dequeuing an item from the shared queue comprising a dequeuing operation;

initiating the execution of a producer code instance that invokes an operation for enqueuing an item to the shared queue comprising an enqueuing operation;

initiating the execution of a callback wrapper associated with the shared queue, comprising a shared queue callback wrapper, when a consumer task instance invokes the dequeuing operation;

utilizing the shared queue callback wrapper to determine if there are any items in the shared queue that are available to be dequeued subsequent to the shared queue callback wrapper being initiated for execution when a consumer task instance invokes the dequeuing operation;

utilizing the shared queue callback wrapper to dequeue an item from the shared queue when there is at least one item stored in the shared queue and the shared queue callback wrapper has been initiated for execution by a consumer task instance invoking the dequeuing operation;

utilizing the shared queue callback wrapper to return an item dequeued from the shared queue to a consumer task instance that invoked the dequeuing operation;

utilizing the shared queue callback wrapper to initiate the resumption of execution for the consumer task instance that invoked the dequeuing operation subsequent to dequeuing an item from the shared queue for the consumer task instance;

utilizing the shared queue callback wrapper to queue the consumer task instance that invoked the dequeuing operation to the consumer callback queue when there are no items stored in the shared queue to be dequeued;

utilizing the shared queue callback wrapper to determine if there is room available in the shared queue to enqueue an item subsequent to the callback wrapper dequeuing an item from the shared queue;

utilizing the shared queue callback wrapper to determine if there is a producer task instance queued to the producer callback queue subsequent to the shared queue callback wrapper determining there is room available in the shared queue to enqueue an item;

utilizing the shared queue callback wrapper to dequeue a producer task instance from the producer callback queue subsequent to the shared queue callback wrapper determining there is room available in the shared queue to enqueue an item;

utilizing the shared queue callback wrapper to enqueue an item produced by a dequeued producer task instance to the shared queue; and

,

utilizing the shared queue callback wrapper to initiate the resumption of execution for a dequeued producer task instance subsequent to enqueuing an item to the shared queue for the dequeued producer task instance.

8. The asynchronous logic flow execution method of claim 7, further comprising:

utilizing the shared queue callback wrapper to determine if there is room in the shared queue to enqueue an item produced by a producer task instance subsequent to the shared queue callback wrapper being initiated for execution when a producer task instance invokes the enqueuing operation;

utilizing the shared queue callback wrapper to enqueue an item produced by a producer task instance when there is room in the shared queue to enqueue an item and the shared queue callback wrapper has been initiated for execution by a producer task instance invoking the enqueuing operation;

utilizing the shared queue callback wrapper to initiate the resumption of execution for the producer task instance that invoked the enqueuing operation subsequent to enqueuing an item to the shared queue for the producer task instance;

utilizing the shared queue callback wrapper to queue a producer task instance that invokes the enqueuing operation to the producer callback queue when there is no room in the shared queue to enqueue an item;

utilizing the shared queue callback wrapper to determine if there is a consumer task instance queued to the consumer callback queue subsequent to the shared queue callback wrapper enqueuing an item to the shared queue;

utilizing the shared queue callback wrapper to dequeue a consumer task instance from the consumer callback queue when the shared queue callback wrapper determines there is at least one item stored in the shared queue available to be dequeued for a consumer task instance;

utilizing the shared queue callback wrapper to dequeue an item for the dequeued consumer task instance from the shared queue;

utilizing the shared queue callback wrapper to return an item dequeued from the shared queue to the dequeued consumer task instance; and

utilizing the shared queue callback wrapper to initiate the resumption of execution for the dequeued consumer task instance subsequent to dequeuing an item from the shared queue for the dequeued consumer task instance.

9. The asynchronous logic flow execution method of claim 7, further comprising utilizing the shared queue callback wrapper to initiate a callback to a consumer task instance to effect the resumption of execution of the consumer task instance.

10. The asynchronous logic flow execution method of claim 9, wherein the callback to a consumer task instance comprises:

obtaining a processing thread for the consumer task instance; and

reassociating the consumer task instance with memory for the subsequent resumption of execution flow processing of the consumer task instance.

11. The asynchronous logic flow execution method of claim 8, further comprising utilizing the shared queue callback wrapper to initiate a callback to a producer task instance to effect the resumption of execution of the producer task instance.

12. The asynchronous logic flow execution method of claim 11, wherein the callback to a producer task instance comprises:

obtaining a processing thread for the producer task instance; and

reassociating the producer task instance with memory for the subsequent resumption of execution flow processing of the producer task instance.

13. The asynchronous logic flow execution method of claim 7, wherein the consumer task is comprised of sequentially developed code and wherein the producer task is comprised of sequentially developed code.

14. The asynchronous logic flow execution method of claim 7, wherein at least one consumer task is defined with a first concurrency at a first time t1 and the at least one consumer task is redefined with a second concurrency that is different than the first concurrency at a second time t2 that is different than the first time t1.

15. The asynchronous logic flow execution method of claim 7, wherein at least one producer task is defined with a first concurrency at a first time t1 and the at least one producer task is redefined with a second concurrency that is different than the first concurrency at a second time t2 that is different than the first time t1.

16. The asynchronous logic flow execution method of claim 7, wherein upon the shared queue callback wrapper initiating the resumption of execution for the consumer task instance that invoked the dequeuing operation subsequent to dequeuing an item from the shared queue for the consumer task instance the consumer task instance resumes execution flow processing at a predetermined logic code line programmed within the consumer task that is subsequent to the code line that when executed in the consumer task instance invokes the dequeuing operation.

17. The asynchronous logic flow execution method of claim 16, wherein the predetermined logic code line programmed within the consumer task for the resumption of execution of a consumer task instance following the execution of a dequeuing operation for the consumer task instance comprises a yield return call.

18. The asynchronous logic flow execution method of claim 8, wherein upon the shared queue callback wrapper initiating the resumption of execution for the producer task instance that invoked the enqueuing operation subsequent to enqueuing an item to the shared queue for the producer task instance the producer task instance resumes execution flow processing at a predetermined logic code line programmed within the producer task that is subsequent to the code line that when executed in the producer task instance invokes the enqueuing operation.

19. The asynchronous logic flow execution method of claim 18, wherein the predetermined logic code line programmed within the producer task for the resumption of execution of a producer task instance following the execution of an enqueuing operation for the producer task instance comprises a yield return call.

20. A method for asynchronous logic flow execution comprising execution of at least one concurrency of a task comprising a task instance, the method comprising:

initiating the execution of a task instance at a first time t1, wherein the task has been developed with sequential task code logic, and wherein initiating the execution of the task instance comprises obtaining a processing thread for the task instance and further comprises referencing the task instance in memory;

upon the task instance invoking the execution of a time consuming operation at a second time t2, invoking a callback wrapper to execute, wherein the callback wrapper manages an asynchronous temporary execution termination for the task code instance;

utilizing the callback wrapper to manage the execution of the time consuming operation invoked by the task instance;

upon the termination of the execution of the time consuming operation, utilizing the callback wrapper to callback the task instance, wherein the callback comprises obtaining a processing thread for the task instance and the callback further comprises re-referencing the task instance in memory; and

upon the execution of the callback, reinstituting processing of the task code instance.