CODE GENERATION FOR REAL-TIME EVENT PROCESSING

• US 20080235658A1
• Filed: 03/21/2007
• Published: 09/25/2008
• Est. Priority Date: 03/21/2007
• Status: Abandoned Application

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: Botzer, David, Oren, David, Adi, Asaf, Shulman, Boris, Magid, Yonit
• Application Number:
  US11/688,882
• Publication Number:
  US 20080235658A1
• Time in Patent Office: Days
• US Class Current: 717/108
• CPC Class Codes: G06F 8/20 Software design

Abstract

A method for information processing includes determining respective execution times for a plurality of operations on a selected computing platform. When a definition of a rule is received, including a complex event and an action to be performed upon occurrence of the complex event, software code is automatically generated to implement the rule on the selected computing platform by invoking a sequence of the operations responsively to the occurrence of the complex event. A worst-case estimate of a duration of execution of the software code is computed, based on the respective execution times of the operations in the sequence. When the worst-case estimate is no greater than a predetermined limit, the software code is run on the selected computing platform so as to cause the action to be performed when the rule is satisfied.

Claims

1. A method for information processing, comprising:

determining respective execution times for a plurality of operations on a selected computing platform;

receiving a definition of a rule comprising a complex event and an action to be performed upon occurrence of the complex event;

automatically generating software code to implement the rule on the selected computing platform by invoking a sequence of the operations responsively to the occurrence of the complex event;

computing a worst-case estimate of a duration of execution of the software code based on the respective execution times of the operations in the sequence; and

when the worst-case estimate is no greater than a predetermined limit, running the software code on the selected computing platform so as to cause the action to be performed when the rule is satisfied.

2. The method according to claim 1, wherein determining the respective execution times comprises storing benchmark times in a repository prior to receiving the definition of the rule, and wherein computing the worst-case estimate comprises reading the benchmark times from the repository.

3. The method according to claim 2, wherein storing the benchmark times comprises determining and storing benchmarks for a plurality of different computing platforms, including the selected computing platform.

4. The method according to claim 2, wherein receiving the definition comprises receiving a set of expressions in a declarative language, and wherein storing the benchmark times comprises determining and storing respective benchmarks for the expressions in the declarative language.

5. The method according to claim 1, wherein receiving the definition comprises receiving expressions in a declarative language, and wherein automatically generating the software code comprises generating run-time code that implements the expressions.

6. The method according to claim 5, wherein generating the run-time code comprises defining a set of abstract operators prior to receiving the definition of the rule, and generating concrete instances of the abstract operators responsively to attributes of the expressions.

7. The method according to claim 6, wherein computing the worst-case estimate comprises determining the execution times of methods used in the concrete instances.

8. Apparatus for information processing, comprising:

a memory, which is arranged to store respective execution times for a plurality of operations on a selected computing platform; and

a code processor, which is arranged to receive a definition of a rule comprising a complex event and an action to be performed upon occurrence of the complex event, and to automatically generate software code to implement the rule on the selected computing platform by invoking a sequence of the operations responsively to the occurrence of the complex event and to compute a worst-case estimate of a duration of execution of the software code based on the respective execution times of the operations in the sequence, such that when the worst-case estimate is no greater than a predetermined limit, the code processor outputs the software code to run on the selected computing platform so as to cause the action to be performed when the rule is satisfied.

9. The apparatus according to claim 8, wherein the respective execution times comprise benchmark times, which are stored in the memory prior to receiving the definition of the rule.

10. The apparatus according to claim 9, wherein the benchmark times are determined and stored in the memory for a plurality of different computing platforms, including the selected computing platform.

11. The apparatus according to claim 9, wherein the code processor is arranged to receive the definition of the rule as a set of expressions in a declarative language, and wherein respective benchmark times for the expressions in the declarative language are determined and stored in the memory for use by the code processor in computing the worst-case estimate.

12. The apparatus according to claim 8, wherein the code processor is arranged to receive the definition of the rule as a set of expressions in a declarative language, and to generate run-time code that implements the expressions.

13. The apparatus according to claim 12, wherein the code processor is arranged to generate the run-time code using a set of abstract operators that is defined prior to receiving the definition of the rule, and to generate concrete instances of the abstract operators responsively to attributes of the expressions.

14. The apparatus according to claim 13, wherein the code processor is arranged to compute the worst-case estimate by determining the execution times of methods used in the concrete instances.

15. A computer software product, comprising a computer-readable medium in which program instructions are stored, which instructions, when read by a computer, cause the computer to read from a memory respective execution times for a plurality of operations on a selected computing platform, and to receive a definition of a rule comprising a complex event and an action to be performed upon occurrence of the complex event, and to automatically generate software code to implement the rule on the selected computing platform by invoking a sequence of the operations responsively to the occurrence of the complex event and to compute a worst-case estimate of a duration of execution of the software code based on the respective execution times of the operations in the sequence, such that when the worst-case estimate is no greater than a predetermined limit, the computer outputs the software code to run on the selected computing platform so as to cause the action to be performed when the rule is satisfied.

16. The product according to claim 15, wherein the respective execution times comprise benchmark times, which are stored in the memory before the computer receives the definition of the rule.

17. The product according to claim 16, wherein the benchmark times are determined and stored in the memory for a plurality of different computing platforms, including the selected computing platform.

18. The product according to claim 16, wherein the instructions cause the computer to receive the definition of the rule as a set of expressions in a declarative language, and wherein respective benchmark times for the expressions in the declarative language are determined and stored in the memory for use by the computer in computing the worst-case estimate.

19. The product according to claim 15, wherein the instructions cause the computer to receive the definition of the rule as a set of expressions in a declarative language, and to generate run-time code that implements the expressions.

20. The product according to claim 19, wherein the instructions cause the computer to generate the run-time code using a set of abstract operators that is defined prior to receiving the definition of the rule, and to generate concrete instances of the abstract operators responsively to attributes of the expressions.