Providing a wrapper around native synchronization objects

• US 8,028,296 B2
• Filed: 03/31/2006
• Issued: 09/27/2011
• Est. Priority Date: 03/31/2006
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Shankar P, Shiva
• Primary Examiner(s): Ho; Andy
• Assistant Examiner(s): DAO, TUAN C.
• Application Number:
  US11/278,356
• Publication Number:
  US 20070234368A1
• Time in Patent Office: 2,006 Days
• Field of Search: 395/704, 718/106, 718/8, 714/3, 711/152
• US Class Current: 719/310
• CPC Class Codes: G06F 9/526 Mutual exclusion algorithms

Abstract

A facility for managing a synchronization mechanism that supports initialization, acquisition, release, and deletion operations is described. When a thread seeks to perform the acquisition operation, the facility permits performance of the acquisition operation only if the initialization operation has been performed more recently than the deletion operation. When a thread seeks to perform the deletion operation, the facility waits until any threads that are seeking to perform the acquisition operation or have performed the acquisition operation more recently than the release operation have performed the release operation before deleting the synchronization mechanism.

Claims

1. A computer-readable storage medium whose contents implement in a computing system functions for accessing a synchronization mechanism, the functions comprising:

a safe initialization function called by a thread to initialize the synchronization mechanism so that the synchronization mechanism can be used by any thread;

a safe acquisition function called by a thread to acquire the synchronization mechanism, in some cases after waiting for release of the synchronization mechanism by a thread that previously acquired the synchronization mechanism;

a safe release function called by a thread to release the synchronization mechanism after acquiring the synchronization mechanism; and

a safe deletion function called by a thread to delete the synchronization mechanism so that the synchronization mechanism can no longer be used by any thread,

the safe acquisition function permitting calling threads to acquire or wait to acquire the synchronization mechanism only if the safe initialization function has been called more recently than the safe deletion function,

the safe deletion function deferring deletion of the synchronization mechanism until any threads that previously acquired the synchronization mechanism release it and until any threads waiting for the synchronization mechanism resume execution.

2. The computer-readable storage medium of claim 1 wherein the safe initialization mechanism sets a flag—

which the safe deletion function clears—

that is tested by the safe acquisition function in order to determine whether to permit calling threads to acquire or wait to acquire the synchronization mechanism.

3. The computer-readable storage medium of claim 1 wherein the safe deletion function:

requires a calling thread to acquire the synchronization mechanism;

after the calling thread has acquired the synchronization mechanism;

marks the synchronization mechanism for deletion; and

releases the synchronization mechanism on behalf of the calling thread.

4. The computer-readable storage medium of claim 3 wherein the safe acquisition function, for each calling thread that is permitted to acquire the synchronization mechanism after the synchronization mechanism is marked for deletion, requires the calling thread to immediately release the synchronization mechanism.

5. The computer-readable storage medium of claim 4 wherein the safe release function deletes the synchronization mechanism when (1) the synchronization mechanism is marked for deletion and (2) the calling thread is the last thread that has acquired or is waiting for the synchronization mechanism.

6. The computer-readable storage medium of claim 1 wherein the functions are provided as a wrapper around native functions implemented for accessing the synchronization mechanism.

7. A method in a computing system having a processor for managing a synchronization mechanism that supports a safe initialization function called by a thread to initialize the synchronization mechanism so that the synchronization mechanism can be used by any thread, a safe acquisition function called by a thread to acquire the synchronization mechanism—

in some cases after waiting for release of the synchronization mechanism by a thread that previously acquired the synchronization mechanism, a safe release function called by a thread to release the synchronization mechanism after acquiring the synchronization mechanism, and a safe deletion function called by a thread to delete the synchronization mechanism so that the synchronization mechanism can no longer be used by any thread operations, comprising;

with the processor, when a thread calls the acquisition function, permitting the calling thread to acquire the synchronization mechanism only if the safe initialization function has been called more recently than the safe deletion function; and

with the processor, when a thread calls the deletion function, waiting until any threads that previously acquired the synchronization mechanism release it and until any threads waiting for the synchronization mechanism resume execution before deleting the synchronization mechanism so that the synchronization mechanism can no longer be used by any thread.

8. The method of claim 7, further comprising, when a thread seeks to perform the deletion operation, forcing any threads that are seeking to perform the release operation immediately after they are permitted to perform the acquisition operation.

9. The method of claim 7 wherein an operating system is executing on the computing system, and wherein the initialization, acquisition, release, and deletion operations of the synchronization mechanism are provided by a synchronization mechanism API of the operating system, and wherein the method is performed by a wrapper around the synchronization mechanism API of the operating system.

10. The method of claim 9 wherein the wrapper maintains one or more indications of (1) the number of threads that are seeking to perform the acquisition operation or have performed the acquisition operation more recently than the release operation, and (2) whether a thread is seeking to perform the deletion operation using atomic variable access operations.

11. The method of claim 10 wherein the wrapper maintains the indications using InterlockedXXX operations provided by the operating system.

12. The method of claim 9 wherein the wrapper is implemented as a safe synchronization mechanism object class.

13. The method of claim 9 wherein the wrapper is implemented in the operating system.

14. A multithreaded computing system, comprising:

a processor;

an operating system executing on the processor;

a resource usable by one or more threads;

a native synchronization mechanism implemented by the operating system for synchronizing access to the resource; and

a synchronization mechanism wrapper through which threads access the native synchronization mechanism,

wherein the native synchronization mechanism provides an initialization operation by which a thread can initialize the native synchronization mechanism for use by any thread, an acquisition operation by which a thread can acquire the native synchronization mechanism, a release operation by which a thread can release the synchronization mechanism after requiring synchronization mechanism, and a deletion operation by which a thread can disable the native synchronization mechanism from use by any thread,

and wherein the synchronization mechanism wrapper prevents any thread from performing the acquisition operation unless the initialization operation has been performed more recently than the deletion operation,

and wherein the synchronization mechanism wrapper prevents any thread from performing the deletion operation until any threads that previously performed the acquisition operation perform the release operation and until any threads waiting for the synchronization mechanism resume execution.

15. The computing system of claim 14 wherein the native synchronization mechanism is a critical section.

16. The computing system of claim 14 wherein the native synchronization mechanism is a mutex.

17. The computing system of claim 14 wherein the native synchronization mechanism is a semaphore.

18. The computing system of claim 14, wherein the acquisition operation provided by the native synchronization mechanism may cause a thread to block that performs the acquisition operation while the native synchronization mechanism is owned by another thread,

and wherein the synchronization mechanism wrapper prevents any thread from performing the deletion operation while any thread performing the acquisition operation is blocked.