TRANSMISSION POINT PATTERN EXTRACTION FROM EXECUTABLE CODE IN MESSAGE PASSING ENVIRONMENTS

• US 20160034262A1
• Filed: 02/23/2015
• Published: 02/04/2016
• Est. Priority Date: 07/17/2012
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Inventors: GARRETT, Charles D.
• Granted Patent: US 9,747,086 B2
• Time in Patent Office: Days
• US Class Current: 1/1
• CPC Class Codes: G06F 8/433 Dependency analysis; Data or control flow analysis
• CPC Class Codes: G06F 8/458 Synchronisation, e.g. post-wait, barriers, locks synchronisation among tasks G06F9/52
• CPC Class Codes: G06F 9/4488 Object-oriented

Abstract

Processes in a message passing system may be launched when messages having data patterns match a function on a receiving process. The function may be identified by an execution pointer within the process. When the match occurs, the process may be added to a runnable queue, and in some embodiments, may be raised to the top of a runnable queue. When a match does not occur, the process may remain in a blocked or non-executing state. In some embodiments, a blocked process may be placed in an idle queue and may not be executed until a process scheduler determines that a message has been received that fulfills a function waiting for input. When the message fulfills the function, the process may be moved to a runnable queue.

Claims

1. A method performed by a computer processor, said method comprising:

compiling source code into executable code;

during said compiling, identifying a first transmission point, said first transmission point being a message passed to another process;

for said first transmission point, identifying a first pattern defining a first output for said first transmission point;

creating a first extractable annotation defining said first pattern; and

storing said first extractable annotation.

2. The method of claim 1, said first pattern being executable code defining a condition for continuing said executable code at said first hold point.

3. The method of claim 1, said first source being a message received from a message created by an executing process.

4. The method of claim 3, said first source being a memory object populated by an executing process.

5. The method of claim 4, said executing process creating an interrupt when said memory object has been populated.

6. The method of claim 5, said executing process being a peripheral device.

7. The method of claim 5, said memory object being a direct memory access memory object.

8. The method of claim 1, said first extractable annotation comprising constants.

9. The method of claim 1, said first executable annotation comprising data types.

10. The method of claim 9, at least one of said data types having no value assigned during said compiling.

11. The method of claim 10, said at least one of said data types having a reference to a value, said value being defined at runtime.

12. The method of claim 1, said first source code being intermediate code.

13. The method of claim 1, said compiling being performed at runtime.

14. The method of claim 12, said first pattern comprising a pattern element defined with a reference to a memory object.

15. The method of claim 14 further comprising:

retrieving a value for said pattern element by traversing said reference to said memory object.

16. The method of claim 1, said executable code being intermediate code.

17. The method of claim 1, said first extractable pattern being stored within said executable code.

18. The method of claim 17, said first extractable pattern being stored in an appendix to said executable code.

19. The method of claim 17, said first extractable pattern being stored in a location adjacent to said first hold point.

20. The method of claim 1, said first extractable pattern being stored in a metadata file, said metadata file being separate from said executable code.

21. The method of claim 20 further comprising:

packaging said metadata file with said executable code.

22. The method of claim 1 further comprising:

identifying a second hold point, said second hold point being a dependency on a second input received from a second source;

for said second hold point, identifying a second pattern defining said second input for said second hold point;

creating a second extractable annotation defining said second pattern;

storing said second extractable annotation;

said first source being a message passing interface; and

said second source being a direct memory access object.

23. The method of claim 1, said first process being written in a functional language.

24. The method of claim 23, said functional language being one of a group composed of:

Erlang;

Scala;

F#;

Lisp;

Clojure;

OCaml; and

Haskell.

25. The method of claim 1, said first process being written in an imperative language.