SYSTEM, METHOD AND COMPUTER PROGRAM PRODUCT FOR PROGRAMMING A CONCURRENT SOFTWARE APPLICATION

• US 20100122253A1
• Filed: 11/09/2009
• Published: 05/13/2010
• Est. Priority Date: 11/09/2008
• Status: Abandoned Application

• Current Assignee: Perry Benjamin Mccart
• Original Assignee: Perry Benjamin Mccart
• Inventors: McCart, Perry Benjamin
• Application Number:
  US12/614,467
• Publication Number:
  US 20100122253A1
• Time in Patent Office: Days
• US Class Current: 718/100
• CPC Class Codes: G06F 8/458 Synchronisation, e.g. post-wait, barriers, locks synchronisation among tasks G06F9/52
• CPC Class Codes: G06F 9/524 Deadlock detection or avoidance
• CPC Class Codes: G06F 9/526 Mutual exclusion algorithms

Abstract

A system, method and computer program product for programming a concurrent software application includes a plurality of shared resources. An ordered list of the shared resources is used by each thread of the application for maintaining a strict total ordering of the shared resources, where each of the shared resources includes a unique identifier. A plurality of mutexes enables a thread to acquire exclusive access to the shared resources. A mutex lock list is associated with a shared resource for maintaining a list of mutex locks acquired during access of the shared resource by the thread. The list is comprised of the mutex associated with the shared resource and all mutexes of shared resources preceding the shared resource in the ordered list, wherein each of the mutex locks has been acquired in an order corresponding to the strict total ordering of the shared resources.

Claims

1. A system for programming a concurrent software application, the system comprising:

a plurality of shared resources;

means for maintaining a strict total ordering of said shared resources;

means for enabling a thread to acquire exclusive access to said shared resources; and

means for maintaining a list of locks acquired during access of a shared resource by said thread, wherein each of said locks has been acquired in an order corresponding to said strict total ordering of said shared resources.

2. The system as recited in claim 1, wherein each of said enabling means enables said thread to acquire said exclusive access a plurality of times.

3. The system as recited in claim 1, wherein said shared resources and said lock list are encapsulated as object classes.

4. The system as recited in claim 1, further comprising means for generating a unique identifier for each of said shared resources that is increasing.

5. A method for programming a concurrent software application, the method comprising:

steps for registering a shared resource for a thread of the application, where said shared resource is uniquely identified;

steps for requesting a lock on said shared resource for exclusive access to said shared resource by said thread;

steps for identifying all shared resources to be locked with said shared resource;

steps for acquiring locks on said identified shared resources and said shared resource;

steps for assigning a lock list of acquired locks to said shared resource;

steps for performing an operation on said shared resource;

steps for releasing said acquired locks upon completion of said operation;

steps for repeating said steps for requesting, identifying, acquiring, assigning, performing and releasing until said thread has completed performing operations on said shared resource; and

steps for unregistering said shared resource.

6. The method as recited in claim 5, further comprising steps for creating a shared resource for a thread of the application.

7. The method as recited in claim 5, further comprising steps for aborting said thread upon determination that registering said shared resource results in an inconsistent ordering.

8. The method as recited in claim 5, further comprising steps for aborting said thread upon determination of a failure of registering said shared resource.

9. The method as recited in claim 5, further comprising steps for encapsulating said shared resource and said lock list as object classes.

10. The method as recited in claim 5, further comprising steps for generating unique identifiers associated with said shared resources that is increasing.

11. A system for programming a concurrent software application, the system comprising:

a plurality of shared resources;

an ordered list of said shared resources used by each thread of the application for maintaining a strict total ordering of said shared resources, where each of said shared resources includes a unique identifier;

a plurality of mutexes, each of said mutexes being associated with a one of said shared resources for enabling a thread to acquire exclusive access to said associated one of said shared resources; and

a mutex lock list associated with a shared resource for maintaining a list of mutex locks acquired during access of said shared resource by said thread, said list comprised of said mutex associated with said shared resource and all mutexes of shared resources preceding said shared resource in said ordered list, wherein each of said mutex locks has been acquired in an order corresponding to said strict total ordering of said shared resources.

12. The system as recited in claim 11, wherein each of said mutexes enables said thread to acquire said exclusive access a plurality of times.

13. The system as recited in claim 11, wherein said mutex locks are released after said access.

14. The system as recited in claim 11, wherein said mutex lock list is populated prior to said access.

15. The system as recited in claim 11, wherein said shared resources and said mutex lock list are encapsulated as object classes.

16. The system as recited in claim 11, wherein said unique identifier is generated to be strictly increasing.

17. A method for programming a concurrent software application, the method comprising steps of:

registering a shared resource for a thread of the application, where said shared resource is uniquely identified in an ordered list of shared resources;

requesting a lock on said shared resource for exclusive access to said shared resource by said thread;

identifying all shared resources in said ordered list, ordered before said shared resource, to be locked with said shared resource;

acquiring locks on mutexes associated with said identified shared resources and said shared resource in an order of placement in said ordered list;

assigning a mutex lock list of acquired mutex locks to said shared resource;

performing an operation on said shared resource;

releasing said acquired mutex locks upon completion of said operation;

repeating said steps of requesting, identifying, acquiring, assigning, performing and releasing until said thread has completed performing operations on said shared resource; and

unregistering said shared resource upon completion of operations on said shared resource by said thread.

18. The method as recited in claim 17, further comprising the step of creating a shared resource for a thread of the application.

19. The method as recited in claim 17, wherein the step of unregistering further comprises removing said shared resource from said ordered list.

20. The method as recited in claim 17, further comprising the step of aborting said thread upon determination that registering said shared resource results in an inconsistent ordering of shared resources among threads in the application.

21. The method as recited in claim 17, further comprising the step of aborting said thread upon determination that said shared resource, for which a lock has been requested, is absent from said ordered list.

22. The method as recited in claim 17, further comprising the step of encapsulating said shared resource and said mutex lock list as object classes.

23. The method as recited in claim 18, further comprising the step of generating unique identifiers associated with said shared resources where said created shared resource has a higher logical ordering unique identifier than previously registered shared resources.

24. A computer program product for programming a concurrent software application, the computer program product comprising:

computer program code for registering a shared resource for a thread of the application, where said shared resource is uniquely identified in an ordered list of shared resources;

computer program code for requesting a lock on said shared resource for exclusive access to said shared resource by said thread;

computer program code for identifying all shared resources in said ordered list, ordered before said shared resource, to be locked with said shared resource;

computer program code for acquiring locks on mutexes associated with said identified shared resources and said shared resource in an order of placement in said ordered list;

computer program code for assigning a mutex lock list of acquired mutex locks to said shared resource;

computer program code for performing an operation on said shared resource;

computer program code for releasing said acquired mutex locks upon completion of said operation;

computer program code for repeating said steps of requesting, identifying, acquiring, assigning, performing and releasing until said thread has completed performing operations on said shared resource;

computer program code for unregistering said shared resource upon completion of operations on said shared resource by said thread; and

a computer-readable media that stores the computer program code.

25. The computer program product as recited in claim 24, further comprising computer program code for creating a shared resource for a thread of the application.

26. The computer program product as recited in claim 24, wherein said computer program code for unregistering further comprises computer program code for removing said shared resource from said ordered list.

27. The computer program product as recited in claim 24, further comprising computer program code for aborting said thread upon determination that registering said shared resource results in an inconsistent ordering of shared resources among threads in the application.

28. The computer program product as recited in claim 24, further comprising computer program code for aborting said thread upon determination that said shared resource, for which a lock has been requested, is absent from said ordered list.

29. The computer program product as recited in claim 24, further comprising computer program code for encapsulating said shared resource and said mutex lock list as object classes.

30. The computer program product as recited in claim 25, further comprising computer program code for generating unique identifiers associated with said shared resources where said created shared resource has a higher logical ordering unique identifier than previously registered shared resources.