Pattern extraction from executable code in message passing environments
View Patent ↗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.
1. A method performed by a computer processor, said method comprising:
compiling source code into executable code;
during said compiling, identifying a first hold point, said first hold point being a dependency on a first input received from a first source;
for said first hold point, identifying a first pattern defining said first input for said first hold point;
creating a first extractable annotation defining said first pattern by annotating said executable code; and
storing said first extractable annotation, said executable code being executable on a second computer processor with said first extractable annotation.
2. The method of claim 1 , said first source being a message received from a message created by an executing process.
3. The method of claim 2 , said first source being a memory object populated by an executing process.
4. The method of claim 3 , said executing process creating an interrupt when said memory object has been populated.
5. The method of claim 4 , said executing process being a peripheral device.
6. The method of claim 4 , said memory object being a direct memory access memory object.
7. The method of claim 1 , said first extractable annotation comprising constants.
8. The method of claim 1 , said first extractable annotation comprising data types.
9. The method of claim 8 , at least one of said data types having no value assigned during said compiling.
10. The method of claim 9 , said at least one of said data types having a reference to a value, said value being defined at runtime.
11. The method of claim 1 , said first source code being intermediate code.
12. The method of claim 1 , said compiling being performed at runtime.
13. The method of claim 11 , said first pattern comprising a pattern element defined with a reference to a memory object.
14. The method of claim 13 further comprising:
retrieving a value for said pattern element by traversing said reference to said memory object.
15. The method of claim 1 , said executable code being intermediate code.
16. The method of claim 1 , said first pattern being stored within said executable code.
17. The method of claim 16 , said first pattern being stored in an appendix to said executable code.
18. The method of claim 1 , said first pattern being stored in a metadata file, said metadata file being separate from said executable code.
19. The method of claim 18 further comprising:
packaging said metadata file with said executable code.
20. 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.
21. The method of claim 1 , said first process being written in a functional language.
22. The method of claim 21 , said functional language being one of a group composed of:
Erlang;
Scala;
F#;
Lisp;
Clojure;
OCaml; and
Haskell.
23. The method of claim 1 , said first process being written in an imperative language.
24. A method of annotating executable code performed by a computer processor, said method comprising:
compiling source code into executable code;
during said compiling, identifying a first hold point in said source code, said first hold point being a location in said source code where a process waits for a message to continue execution;
identifying a pattern of data expected to fulfill said hold point so that said process continues execution;
said pattern comprising: predefined data constants and references to data created at runtime;
for said predefined data constants, extracting said predefined data constants from said source code and annotating said executable code to include said predefined data constants as associated with said first hold point;
for said references to data created as runtime, extracting said references and annotating said executable code with a first extractable annotation, said first extractable annotation including-said references as associated with said first hold point;
said executable code being executable on a second computer processor with said first extractable annotation.
25. A method executed at runtime performed by a computer processor, said method comprising:
executing executable code until reaching a first hold point, said first hold point defining a set of conditions satisfied by a message received from a source;
analyzing said executable code to extract a pattern of data expected from said source, said pattern comprising predefined data constants defined in said executable code; and
storing said pattern in said executable code as a first extractable annotation, said executable code being executable on a second computer processor with said first extractable annotation.
26. The method of claim 25 further comprising:
said pattern further comprising pointers to stored data;
following said pointers to retrieve said stored data; and
adding said stored data to said pattern.