Concurrent exception handling using an aggregated exception structure

• US 8,146,085 B2
• Filed: 06/25/2007
• Issued: 03/27/2012
• Est. Priority Date: 06/25/2007
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Duffy, John Joseph, Callahan, David, Detlefs, David, Morrison, Vance, Grunkemeyer, Brian, Tribble, Eric Dean
• Primary Examiner(s): NGUYEN, VAN H
• Application Number:
  US11/821,647
• Publication Number:
  US 20080320275A1
• Time in Patent Office: 1,737 Days
• Field of Search: 718/100, 712/244
• US Class Current: 718/100
• CPC Class Codes: G06F 11/36 Preventing errors by testing or debugging software
• CPC Class Codes: G06F 2209/481 Exception handling
• CPC Class Codes: G06F 9/4812 by interrupt, e.g. masked

Abstract

Various technologies and techniques are disclosed for providing concurrent exception handling. Exceptions that occur in concurrent workers are caught. The caught exceptions are then forwarded from the concurrent workers to a coordination worker. The caught exceptions are finally aggregated into an aggregation structure, such as an aggregate exception object. This aggregation structure is rethrown and the individual caught exceptions may then be handled at a proper time.

Claims

1. A computer storage medium having computer-executable instructions for causing a computer to perform steps comprising:

catching exceptions that occur in concurrent worker tasks of a program;

forwarding the caught exceptions from the concurrent worker tasks to a coordination task;

aggregating the caught exceptions into an aggregation structure; and

rethrowing the aggregation structure from the coordination task so that the caught exceptions can be handled by the program at a proper time,

wherein the caught exceptions are aggregated into the aggregation structure if an unhandled exception occurs on one of the concurrent worker tasks, and

wherein the proper time for aggregating and rethrowing the caught exceptions in the aggregation structure is when all of the concurrent worker tasks finish executing.

2. The computer storage medium of claim 1, wherein the aggregation structure is an aggregation exception object.

3. The computer storage medium of claim 2, wherein the aggregate exception object is provided to an exception handler so the exceptions can be handled by the program at the proper time.

4. The computer storage medium of claim 1, wherein the coordination task is responsible for tracking the recognized exceptions from the concurrent worker tasks.

5. The computer storage medium of claim 1, wherein one or more of the caught exceptions are removed from the aggregation structure as being redundant exceptions.

6. The computer storage medium of claim 1, wherein the aggregation structure is an output stream that contains concurrent exceptions interleaved with normal output.

7. A method for aggregating many exceptions into a single aggregate exception object comprising the steps of:

catching exceptions that occur in concurrent worker tasks of a program;

forwarding the caught exceptions from the concurrent worker tasks to a coordination task;

aggregating the caught exceptions into a single aggregate exception object; and

rethrowing the single aggregate exception object from the coordination task so that the caught exceptions can be handled by the program at a proper time,

wherein the caught exceptions are aggregated into the single aggregate exception object if an unhandled exception occurs on one of the concurrent worker tasks, and

wherein the proper time for aggregating and rethrowing the caught exceptions in the single aggregate exception object is when all of the concurrent worker tasks finish executing.

8. The method of claim 7, wherein the single aggregate exception object can also store related information about each of the plurality of exceptions.

9. The method of claim 8, wherein the related information includes an identifier of the thread which originally threw the exception.

10. The method of claim 8, wherein the related information includes an original stack trace.

11. The method of claim 8, wherein the related information includes application programming interface specific information about a concurrent operation that resulted in a particular exception.

12. The method of claim 7, wherein the one or more of the plurality of exceptions are removed from the single aggregate exception object as being redundant exceptions.

13. The method of claim 7, wherein the proper time at which the aggregate exception object is provided to the exception handler is after a first exception occurs on one of the concurrent worker tasks.

14. A computer storage medium having computer-executable instructions for causing a computer to perform the steps recited in claim 7.

15. A method for terminating concurrent worker tasks after a first concurrent exception occurs comprising the steps of:

providing a coordination task that initializes a shared flag and a shared location;

starting concurrent worker tasks;

as soon as a first concurrent exception is thrown, setting the shared flag and logging the exception to the shared location;

when each respective concurrent worker task subsequently polls the shared flag to see if the shared flag was set, the respective task voluntarily terminates;

if any further exceptions occur before each respective task terminates, logging those further exceptions to the shared location;

waiting for all of the concurrent worker tasks to terminate; and

creating an aggregate exception object out of any exceptions logged to the shared location and then throwing the aggregate exception object for proper handling.

16. The method of claim 15, wherein the shared location contains a collection of exceptions.

17. A computer storage medium having computer-executable instructions for causing a computer to perform the steps recited in claim 15.