Multithreading with concurrency domains

• US 7,581,225 B2
• Filed: 02/23/2006
• Issued: 08/25/2009
• Est. Priority Date: 04/29/2005
• Status: Expired due to Fees

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Cran, Simeon, Szyperski, Clemens A., Olenick, Brad M., Shyamsundar, Balasubramanian, Ahmad, Arshad F.
• Primary Examiner(s): CAO, DIEM K
• Application Number:
  US11/360,454
• Publication Number:
  US 20060248530A1
• Time in Patent Office: 1,279 Days
• Field of Search: 719310-320, 719328-330, 709/213
• US Class Current: 719/314
• CPC Class Codes: G06F 2209/509 Offload
• CPC Class Codes: G06F 9/5027 the resource being a machine, e.g. CPUs, Servers, Terminals
• CPC Class Codes: G06F 9/52 Program synchronisation; Mutual exclusion, e.g. by means of semaphores
• CPC Class Codes: G06F 9/541 via adapters, e.g. between incompatible applications
• CPC Class Codes: G06F 9/544 Buffers; Shared memory; Pipes

Abstract

Methods, systems and computer products are provided for partitioning software application components into separate domains called concurrency domains. Computationally expensive, slow or long-running methods may be deployed into such domains, thus keeping the associated application more responsive to the end user. According to one aspect of the invention, a given concurrency domain is a partition of runtime objects for providing synchronization and thread isolation within the partition and for providing concurrency with other such partitions in a data-driven dynamically composed and reconfigured application.

Claims

1. A system for synchronizing operations of components of a software application, comprising:

a memory; and

a processor, coupled to the memory, configured to process items associated with the software application including;

a first concurrency domain that is a partition of user interface components of the software application and is for providing synchronization and thread isolation for the partitioned components, wherein the first concurrency domain includes a single internal processing thread operative to execute a single-threaded object of the software application;

a first boundary object associated with the first concurrency domain for facilitating asynchronous communications between the first concurrency domain and an external object, wherein the first boundary object is operative to;

receive a first work item from a software application object external to the first concurrency domain,

determine whether at least one previously posted work item in a work item queue comprises a related task to the first work item,

in response to determining that the at least one previously posted work item in a work item queue comprises a related task to the first work item, bundle the first work item with the previously posted work item in the work item queue, and

in response to determining that the at least one previously posted work item in a work item queue does not comprise a related task, post the first work item to the work item queue, the first work item being directed to the single-threaded object;

a first thread dispatcher object included in the concurrency domain operative to retrieve the posted first work item from the work item queue and to pass the posted first work item to the single-threaded object for processing by the single-threaded object; and

the single-threaded object being operative to process the posted first work item and to return a result to the external object via the first boundary object such that when the first work item is to be processed in the first concurrency domain is determined by the first thread dispatcher object.

2. The system of claim 1, whereby the first thread dispatcher object is further operative to withhold from the single-threaded object a posted second work item directed to the single-threaded object until the single-threaded object returns a result from a processing of the posted first work item to the external object via the first boundary object.

3. The system of claim 2, wherein the external object comprises a secondary concurrency domain, the secondary concurrency domain being created by the first concurrency domain serving as parent domain to perform tasks for the software application and to publish results to another concurrency domain,

including a single internal thread configured for execution of at least one other single-threaded object included in the secondary concurrency domain, and

being associated with a secondary concurrency domain boundary object operative to receive the result from the single-threaded object via the first boundary object for processing by the single-threaded object included in the secondary concurrency domain.

4. A method for synchronizing operations of components of a software application, comprising:

receiving first a work item for processing by a first software application component instantiated in a main concurrency domain that is a partition of user interface components of the software application and is for providing synchronization and thread isolation for the partitioned components, wherein an additional concurrency domain is created by the main concurrency domain to perform tasks for the software application and to publish results to the main concurrency domain;

determining whether at least one previously posted work item in a work item queue comprises a related task to the first work item;

in response to determining that the at least one previously posted work item in a work item queue comprises a related task to the first work item, bundle the first work item with the previously posted work item in the work item queue;

in response to determining that the at least one previously posted work item in a work item queue does not comprise a related task, posting the work item in the work item queue by a boundary object of the of the main concurrency domain comprising one of;

a data connector and an object for facilitating asynchronous communications between concurrency domains;

determining whether the first software application component has finished processing any previous work items passed to the first software application component for processing;

if the first software application component has finished processing any previous work items passed to the first software application component for processing, retrieving the work item posted to the work item queue by a dispatcher object; and

passing the retrieved work item to the first software application component for processing such that internal and external reentrancy problems are prevented.

5. The method of claim 4, prior to receiving a work item for processing by the first software application component, instantiating the first software application component in the main concurrency domain separate from other components of the software application including a single internal processing thread operative to execute the first software application component.

6. The method of claim 5,

wherein receiving a work item for processing by a first software application component includes receiving the work item at the boundary object associated with the main concurrency domain from an object of the software application that is external to the main concurrency domain, the work item being directed to the first software application component.

7. The method of claim 6, wherein determining whether the first software application component has finished processing any previous work items passed to the first software application component for processing includes determining whether the dispatcher object provided in the main concurrency domain has been notified that results from any previous work items passed to the first software application component have been passed from the first software application component to the boundary object.

8. The method of claim 7, wherein passing the retrieved work item to the first software application component for processing includes causing the dispatcher object to pass the retrieved work item to the software application component for processing in response to being notified that results from any previous work items passed to the first software application component have been passed from the first software application component to the boundary object.

9. The method of claim 8, further comprising causing the dispatcher object to withhold from the first software application component a posted second work item directed to the first software application component until the first software application component returns a result from a processing of the retrieved work item to the first software application component via the boundary object.

10. The method of claim 9, wherein causing the dispatcher object to withhold from the first software application component a posted second work item directed to the first software application component includes preventing the first software component from requesting the posted second work item such that the first software application component may only receive the posted second work item for processing when the dispatcher object determines that the first software application component is ready to process the posted second work item.

11. The method of claim 9, wherein receiving the work item at a boundary object associated with the concurrency domain from an object of the software application that is external to the concurrency domain includes receiving the work item at the boundary object from the additional concurrency domain, the additional concurrency domain including a single internal thread configured for execution of second software application component included in the additional concurrency domain, and the additional concurrency domain being associated with a second boundary object operative to receive the result from the first software application component via the boundary object.

12. A computer readable storage medium containing computer executable instructions which when executed by a computer perform a method of concurrently executing single-threaded and multithreaded objects, comprising:

receiving a software application containing a plurality of software components operative for processing data concurrently;

separating each of the software components operative for processing data concurrently into separate concurrency domains, wherein a main concurrency domain is associated with user interface components of the software application, and a secondary concurrency domain is created by the main concurrency domain to perform tasks for the software application and to publish results to the main concurrency domain;

associating a boundary object with each separate concurrency domain for receiving any data calls directed to software component objects contained in the separate concurrency domains, wherein the boundary object is operative to;

receive a first work item from a software application object external to the first concurrency domain,

determine whether at least one previously posted work item in a work item queue associated with the boundary object comprises a related task to the first work item,

in response to determining that the at least one previously posted work item in a work item queue comprises a related task to the first work item, bundle the first work item with the previously posted work item in the work item queue, and

in response to determining that the at least one previously posted work item in a work item queue does not comprise a related task, post the first work item to the work item queue, the first work item being directed to the single-threaded object; and

disposing a dispatcher object in each of the separate concurrency domains for presenting data calls to individual software component objects after the individual software component objects have completed processing of other data calls previously presented to the individual software component objects such that internal and external reentrancy problems are prevented.

13. The computer storage readable medium of claim 12, further comprising:

in the main concurrency domain, executing a single-threaded object in response to a data call received from the dispatcher object using a single processing thread internal to the main concurrency domain, the single processing thread executing without direct calls from any secondary threads external of the main concurrency domain; and

executing an external object that is not included in the main concurrency domain using a secondary processing thread, the secondary processing thread executing without direct calls from the single processing thread in the main concurrency domain.

14. The computer readable storage medium of claim 13, further comprising

interfacing between the single processing thread internal to the main concurrency domain internal thread and the secondary processing thread using a boundary object associated with the main concurrency domain.

15. The computer readable storage medium of claim 14, wherein the secondary processing thread includes a second single processing thread internal to the secondary concurrency domain, where the second single processing thread is configured to execute single-threaded objects contained in the secondary concurrency domain, the secondary concurrency domain having an associated boundary object for interfacing with the boundary object associated with the main concurrency domain.

16. The computer readable storage medium of claim 15, wherein work items are deposited in the work queue associated with each boundary object until retrieved by an associated dispatcher object for presentation to a given individual software component object.

17. The computer readable storage medium of claim 16, further comprising receiving a data call at the boundary object associated with the main concurrency domain from the secondary concurrency domain for execution by a given software component object contained in the main concurrency domain via the boundary object associated with the secondary concurrency domain.

18. The computer readable storage medium of claim 17, further comprising depositing the data call from the secondary concurrency domain in a work queue associated with the main concurrency domain.

19. The computer readable storage medium of claim 18, wherein if the given software component object contained in the main concurrency domain has completed processing any previously received data calls, causing a dispatcher object associated with the main concurrency domain to retrieve the data call from the secondary concurrency domain from the work queue associated with the main concurrency domain, and causing the dispatcher object associated with the main concurrency domain to present the data call from the secondary concurrency domain to the given software component object contained in the main concurrency domain for processing.

20. A method for synchronizing operations of components of a software application, comprising:

instantiating a first software application component in a main concurrency domain separate from other components of the software application including a single internal processing thread operative to execute the first software application component;

creating, by the main concurrency domain, an additional concurrency domain is to perform tasks for the software application and to publish results to the main concurrency domain;

receiving a first work item for processing by the first software application component at a boundary object associated with the main concurrency domain from an external object;

determining, at the boundary object, whether at least one previously posted work item in a work item queue associated with the boundary object comprises a related task to the first work item;

in response to determining that the at least one previously posted work item in a work item queue comprises a related task to the first work item, bundle the first work item with the previously posted work item in the work item queue;

in response to determining that the at least one previously posted work item in a work item queue does not comprise a related task, posting the work item in the work item queue by a boundary object of the of the main concurrency domain comprising one of;

a data connector and an object for facilitating asynchronous communications between concurrency domains;

determining whether the first software application component has finished processing any previous work items passed to the first software application component for processing, wherein determining whether the first software application component has finished processing any previous work items passed to the first software application component for processing includes determining whether a dispatcher object provided in the main concurrency domain has been notified that results from any previous work items passed to the first software application component have been passed from the first software application component to the boundary object;

if the first software application component has finished processing any previous work items passed to the first software application component for processing, retrieving the work item posted to the work item queue by the dispatcher object;

passing the retrieved work item to the first software application component for processing such that internal and external reentrancy problems are prevented, wherein passing the retrieved work item to the first software application component for processing comprises causing the dispatcher object to pass the retrieved work item to the software application component for processing in response to being notified that results from any previous work items passed to the first software application component have been passed from the first software application component to the boundary object; and

causing the dispatcher object to withhold from the first software application component a posted second work item directed to the first software application component until the first software application component returns a result from a processing of the retrieved work item to the first software application via the boundary object.