Method And Systems For Providing Concurrency Control For Addressable Entities

• US 20080320459A1
• Filed: 06/22/2007
• Published: 12/25/2008
• Est. Priority Date: 06/22/2007
• Status: Abandoned Application

• Current Assignee: Scenera Technologies LLC (Scenera Research LLC)
• Original Assignee: Scenera Technologies LLC (Scenera Research LLC)
• Inventors: Morris, Robert P.
• Application Number:
  US11/766,948
• Publication Number:
  US 20080320459A1
• Time in Patent Office: Days
• US Class Current: 717/162
• CPC Class Codes: G06F 9/526 Mutual exclusion algorithms

Abstract

Methods and systems are described for providing concurrency control for addressable entities. In one embodiment, a concurrency policy is associated with an addressable entity in an executable program component generated from source code, the concurrency policy controlling an order of access by a plurality of runtime processes each executing machine code instructions for accessing the addressable entity, the machine code instructions generated from source code, wherein the concurrency policy is associated with the addressable entity independent of the source code of the executable program component and the source code of the machine code instructions. An attempt to access the addressable entity by a machine code instruction executed by a runtime process of the plurality of runtime processes is detected. The machine code instruction is allowed to access the addressable entity based on the concurrency policy.

Claims

1. A method for providing concurrency control for addressable entities, the method comprising:

associating a concurrency policy with an addressable entity in an executable program component generated from source code, the concurrency policy controlling an order of access by a plurality of runtime processes each executing machine code instructions for accessing the addressable entity, the machine code instructions generated from source code, wherein the concurrency policy is associated with the addressable entity independent of the source code of the executable program component and the source code of the machine code instructions;

detecting an attempt to access the addressable entity by a machine code instruction executed by a runtime process of the plurality of runtime processes; and

allowing the machine code instruction to access the addressable entity based on the concurrency policy.

2. The method of claim 1 wherein the source code of the executable program is in a processor independent programming language, wherein a plurality of machine code instructions, each executable by a specified processor from a different processor architecture family, can be generated from the source code.

3. The method of claim 1 wherein the concurrency policy controls an order of access by a plurality of runtime processes with instructions not supported by a programming language of the source code of the executable program component and the source code of the machine code instructions.

4. The method of claim 1 wherein associating a concurrency policy with an addressable entity includes selecting the concurrency policy for association with the addressable entity according to an attribute of the addressable entity.

5. The method of claim 4 wherein the attribute of the addressable entity includes at least one of a value attribute including an acceptable value of the addressable entity, a category attribute including a category of addressable entities associated with the addressable entity, a scope attribute including a section of the executable program component wherein the addressable entity is known, and a symbol attribute including an identifier of the addressable entity.

6. The method of claim 1 wherein associating a concurrency policy with an addressable entity includes associating a concurrency system with the addressable entity for controlling an order of access to the addressable entity.

7. The method of claim 6 including detecting an execution environment condition during the processing of the executable program component, wherein associating the concurrency system with the addressable entity is based on the detected execution environment condition.

8. The method of claim 1 wherein associating a concurrency policy with an addressable entity includes associating the concurrency policy with a memory location associated with the addressable entity, wherein a memory management system detects an attempt to access the memory location.

9. The method of claim 1 wherein the concurrency policy requires serialized access to the addressable entity, wherein an access to the addressable entity by a first runtime process of the plurality of runtime processes prevents access to the addressable entity by a second runtime process the plurality of runtime processes.

10. The method of claim 1 wherein

detecting an attempt to access the addressable entity by a machine code instruction includes determining a type of access associated with the machine code instruction, and

wherein allowing the machine code instruction to access the addressable entity is based on the type of access associated with the machine code instruction and the concurrency policy.

11. The method of claim 1 wherein detecting an attempt to access the addressable entity includes invoking an interceptor in response to detecting the attempt to access the addressable entity, the interceptor transferring control to a concurrency enforcer.

12. The method of claim 1 including

in response to detecting an attempt to access the addressable entity by a machine code instruction, invoking an event handler based on the concurrency policy.

13. A system for providing concurrency control for addressable entities, the system comprising:

means for associating a concurrency policy with an addressable entity in an executable program component generated from source code, the concurrency policy controlling an order of access by a plurality of runtime processes each executing machine code instructions for accessing the addressable entity, the machine code instructions generated from source code, wherein the concurrency policy is associated with the addressable entity independent of the source code of the executable program component and the source code of the machine code instructions;

means for detecting an attempt to access the addressable entity by a machine code instruction executed by a runtime process of the plurality of runtime processes; and

means for allowing the machine code instruction to access the addressable entity based on the concurrency policy.

14. A system for providing concurrency control for addressable entities, the system comprising:

an entity access monitor component configured for associating a concurrency policy with an addressable entity in an executable program component generated from source code, the concurrency policy controlling an order of access by a plurality of runtime processes each executing machine code instructions for accessing the addressable entity, the machine code instructions generated from source code, wherein the concurrency policy is associated with the addressable entity independent of the source code of the executable program component and the source code of the machine code instructions;

an access detector component configured for detecting an attempt to access the addressable entity by a machine code instruction executed by a runtime process of the plurality of runtime processes; and

a concurrency enforcer component configured for allowing the machine code instruction to access the addressable entity based on the concurrency policy.

15. The system of claim 14 wherein the source code of the executable program is in a processor independent programming language, wherein a plurality of machine code instructions, each executable by a specified processor from a different processor architecture family, can be generated from the source code.

16. The system of claim 14 wherein the concurrency enforcer component is configured for controlling an order of access to the addressable entity with instructions not supported by a programming language of the source code of the executable program component and the source code of the machine code instructions.

17. The system of claim 14 wherein the entity access monitor component is configured for selecting the concurrency policy for association with the addressable entity according to an attribute of the addressable entity.

18. The system of claim 17 wherein the attribute of the addressable entity includes at least one of a value attribute including an acceptable value of the addressable entity, a category attribute including a category of addressable entities associated with the addressable entity, a scope attribute including a section of the executable program component wherein the addressable entity is defined, and a symbol attribute including an identifier of the addressable entity.

19. The system of claim 14 wherein the entity access monitor component is configured for associating a concurrency system with the addressable entity for controlling an order of access to the addressable entity.

20. The system of claim 19 including a system monitor component configured for detecting an execution environment condition during the processing of the executable program component, and wherein the entity access monitor component is configured for associating the concurrency system with the addressable entity is based on the detected execution environment condition.

21. The system of claim 14 wherein the entity access monitor component is configured associating the concurrency policy with a memory location associated with the addressable entity, and including a memory management system component configured for detecting an attempt to access the memory location.

22. The system of claim 14 wherein the concurrency policy requires serialized access to the addressable entity, wherein the concurrency enforcer component is configured for preventing access to the addressable entity by a second runtime process the plurality of runtime processes in response to an access to the addressable entity by a first runtime process of the plurality of runtime processes.

23. The system of claim 14 wherein the access detector component is configured for determining a type of access associated with the machine code instruction, and wherein the concurrency enforcer component is configured for allowing the machine code instruction to access the addressable entity is based on the type of access associated with the machine code instruction and the concurrency policy.

24. The system of claim 14 including an interceptor component configured for transferring control to the concurrency enforcer component, wherein the access detector component is configured for invoking the interceptor component in response to detecting the attempt to access the addressable entity.

25. The system of claim 14 including an event handler component configured for performing an action associated with a machine code instruction, wherein the access detector component is configured for, in response detecting an attempt to access the addressable entity by a machine code instruction executed by a runtime process of the plurality of runtime processes, invoking the event handler component based on the concurrency policy.

26. A computer readable medium including a computer program, executable by a machine, for providing concurrency control for addressable entities, the computer program comprising executable instructions for:

associating a concurrency policy with an addressable entity in an executable program component generated from source code, the concurrency policy controlling an order of access by a plurality of runtime processes each executing machine code instructions for accessing the addressable entity, the machine code instructions generated from source code, wherein the concurrency policy is associated with the addressable entity independent of the source code of the executable program component and the source code of the machine code instructions;

detecting an attempt to access the addressable entity by a machine code instruction executed by a runtime process of the plurality of runtime processes; and

allowing the machine code instruction to access the addressable entity based on the concurrency policy.