Multithreading with concurrency domains

• US 20060248530A1
• Filed: 02/23/2006
• Published: 11/02/2006
• Est. Priority Date: 04/29/2005
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Szyperski, Clemens A., Olenick, Brad M., Shyamsundar, Balasubramanian, Ahmad, Arshad F., Cran, Simeon
• Granted Patent: US 7,581,225 B2
• Time in Patent Office: Days
• US Class Current: 718/102
• 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 first concurrency domain including a single internal processing thread operative to execute at least one single-threaded object of the software application;

a first boundary object associated with the first concurrency domain operative to receive a first work item from a software application object external to the first concurrency domain and operative to post the first work item to a 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.

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, whereby the external object comprises a secondary concurrency domain, the secondary concurrency domain including a single internal thread configured for execution of at least one single-threaded object included in the secondary concurrency domain, and the secondary concurrency domain 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 a work item for processing by a first software application component;

posting the work item in a work item queue;

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; and

passing the retrieved work item to the software application component for processing.

5. The method of claim 4, prior to receiving a work item for processing by a first software application component, instantiating the first software application component in a 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,

whereby receiving a work item for processing by a first software application component includes 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, the work item being directed to the first software application component;

and

whereby posting the work item in a work item queue includes causing the boundary object to post the work item in a work item queue for subsequent processing by the first software application component.

7. The method of claim 6, whereby 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 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, whereby retrieving the work item posted to the work item queue includes causing the dispatcher object to retrieve the work item posted to the work item queue 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, whereby passing the retrieved work item to the 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.

10. The method of claim 9, 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 external object via the first boundary object.

11. The method of claim 10, whereby 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.

12. The method of claim 10, whereby 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 a secondary concurrency domain, the secondary concurrency domain including a single internal thread configured for execution of second software application component included in the secondary concurrency domain, and the secondary concurrency domain being associated with a secondary concurrency domain boundary object operative to receive the result from the first software application component via the first boundary object.

13. A computer readable 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;

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; 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.

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

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

executing at least one external object that is not included in the given concurrency domain using a secondary processing thread, the secondary processing thread executing without direct calls from the single processing thread in the given concurrency domain.

15. The computer readable medium of claim 14, further comprising interfacing between the single processing thread internal to the first given concurrency domain internal thread and the secondary processing thread using a boundary object associated with the first given concurrency domain.

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

17. The computer readable medium of claim 16, further comprising, associating a work queue with each boundary object for holding data calls directed to individual software component objects associated with each respective boundary object wherein data calls received by a given boundary object are deposited in an associated work queue until retrieved by an associated dispatcher object for presentation to a given individual software component object.

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

19. The computer readable medium of claim 18, further comprising depositing the data call from the second given concurrency domain for in a work queue associated with the first given concurrency domain.

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