Patent Application
20120192149
Program listings in the disclosure of this patent document contain material that is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.
The present invention relates generally to computer systems and software, and specifically to tools and methods for programming the response of a computer system to specified events.
There are many applications in which a computer must detect, evaluate and respond to events. Such events may include substantially any occurrence of interest that is detected by the computer, such as a change in the price of a stock, the beginning of a banking transaction, change of an entry in a database, or a suspected fault in a computer or communication system. The timing, sequence and content of these events are generally not known in advance. Various tools have been developed in order to allow events and their attendant reactions to be specified in a general, flexible way.
For example, U.S. Pat. No. 6,604,093 describes a situation awareness system. The system uses a language that enables complex events to be defined as the composition of multiple simple events, such as successive withdrawals from one or more bank accounts. In addition, a particular order and other timing constraints on the component events may be specified. Once the complex event has been detected, there may be one or more conditions that qualify the event, for example, that the amounts of the withdrawals be greater than a specified threshold. If the conditions are satisfied, then an action is triggered, such as alerting the bank's security manager of a possible fraud.
Aspects of the situation management system described in U.S. Pat. No. 6,604,093 are implemented in IBM Active Middleware Technology™ (formerly known as AMiT), a situation management tool developed at IBM Haifa Research Laboratory (Haifa, Israel). This tool is described in an article by Adi and Etzion entitled, “AMiT—the Situation Manager,” VLDB Journal 13 (2) (Springer-Verlag, May, 2004), pages 177-203.
Some event-processing systems have real-time performance requirements that cannot always be met by conventional, general-purpose processing engines such as the one provided by IBM Active Middleware Technology. In telecommunications applications, for example, a variety of adjunct switching services such as debit-based billing, number mapping, call forwarding, and local-number portability involve event processing during the critical call-connection phase of a telephone call. To meet the real-time requirements of the network, the service time for such events generally must not exceed a few milliseconds. These limitations have led to the use of custom database systems for many high-performance real-time event processing applications.
As an alternative, U.S. Pat. No. 6,496,831 describes a general-purpose real-time event processing system (EPS), which is said to avoid the problems associated with custom systems. The EPS uses one or more real-time analysis engines (RAEs), operating in conjunction with a main-memory storage manager as its underlying database system. The main-memory storage manager offers transactional access to persistent data, but at the speed of a main-memory system. The EPS may implement a parallel arrangement of RAEs for scalability as workload and resources increase. Other real-time event processing systems are described in U.S. Pat. No. 6,449,618, U.S. Pat. No. 6,502,133, U.S. Pat. No. 6,681,230, and U.S. Pat. No. 6,968,552.
A disclosed embodiment of the present invention provides a method for information processing. A set of abstract operators is defined for use in implementing computing operations—including iterative operations—that are associated with event processing. Respective execution times are determined in advance for the operations implemented by the abstract operators on a selected computing platform. A rule is defined as 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 generating concrete instances of the abstract operators so as to invoke a sequence of computing steps that includes iterations of the iterative 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 with the iterations. When the worst-case estimate is no greater than a predetermined limit, the software code may be run on the selected computing platform so as to cause the action to be performed when the rule is satisfied.
Other embodiments of the invention provide apparatus and computer software products.
The present invention will be more fully understood from the following detailed description of the embodiments thereof, taken together with the drawings in which:
The term “real-time processing” can have different meanings in different applications. In the field of event processing, the term generally means that the event-processing system completes its handling of a given event within a short time of the occurrence of the event. Even “short” in this context is not well defined, since some real-time applications may require that events be processed within a few milliseconds of occurrence (or even less), while others require that processing be completed within seconds or even minutes of the event. What is common, however, to all of these “real-time” applications is that there is a specified time limit that the event-processing software must reliably meet. General-purpose event-processing engines, such as the above-mentioned IBM Active Middleware Technology engine, can be configured flexibly to perform a wide range of event-processing tasks, but they do not generally offer this sort of real-time performance predictability.
Embodiments of the present invention, on the other hand, provide methods and systems for automatic generation of software code for real-time event processing in which processing time for specified complex events is guaranteed to be no greater than a specified limit. This sort of system, as described in detail hereinbelow, generates code to implement declarative definitions of event processing rules that are input by a user. By analyzing the operations that the code will have to perform in processing a given rule, the code generation system is able to compute in advance a worst-case estimate of the duration of execution of the code on a given computing platform. The user can thus determine with high confidence that the real-time performance of the code will be adequate, or take corrective measures if the worst-case estimate is too high.
One of the challenges in setting reliable bounds on execution times is that software code—including code for real-time event processing—generally contains loops, which can go through many iterations in the course of execution. In an embodiment of the present invention, the code generation system addresses this challenge by identifying iterative operations invoked in implementing the rules and taking the iterations of these operations into account in computing the worst-case estimates. Specifically, the system may derive a bound on the number of iterations that will occur at run-time, and then multiply this bound by the execution time of the single iteration to generate the worst-case estimate. The system typically calculates the bound by analyzing the definition of the rule itself, which indicates the maximal number of situation components, such as simple events, that may have to be processed in detecting the occurrence of the complex event.
For each rule that is defined by user 24, processor 22 determines the sequence of processing operations that will have to be performed by the corresponding software code, and then looks up the worst-case execution time for each operation in a data repository 30, such as a database. The generated code is typically not a “straight-line” sequence of steps, but rather contains iterations. Processor 22 predicts a worst-case bound on the number of the iterations and can thus calculate the worst-case bound for the entire execution based on the repository of execution times for basic operations.
Typically, these execution times are measured in advance for each type of operation by running benchmark execution tests on a test platform 32, using methods of benchmarking that are known in the art. Alternatively, execution times of simple, straight-line program building blocks (such as single-line commands) may be calculated using methods of modeling that are known in the art, as described, for example, by Harmon et al., in “A Retargetable Technique for Predicting Execution Time of Code Segments,” IEEE Real-Time Systems Symposium (1992), pages 69-77, whose disclosure is incorporated herein by reference. The execution time for each type of operation depends, of course, on the computing platform on which the software is to execute. Therefore, for each type of operation, repository 30 may contain worst-case estimates with respect to a number of different platforms. Processor 22 may thus compute and inform user 24 of the worst-case execution times for a given rule on two or more different platforms, thus enabling the user to choose a more powerful platform if necessary to meet the real-time system requirements.
Processor 22 generates real-time software code to implement rules 27 that are input by user 24. In an exemplary embodiment, which is described in greater detail hereinbelow, the user inputs the rules in the form of declarative statements. Processor 22 translates these statements into corresponding software classes, which inherit from a predefined set of abstract classes. The rule syntax and abstract classes may be designed specifically for efficient, predictable execution, by limiting the number and/or lifespans of events that may be included in a rule, for example, and limiting access to non-real-time external resources, such as large databases.
When code generation is complete, and user 24 has determined that the worst-case execution time is within acceptable limits, the run-time code is compiled and loaded into an execution platform 34. This platform typically comprises a general- or special-purpose computer, with an interface for receiving indications of events from a source or set of sources 36. (Sources 36 are represented in
The sample code above defines a “situation,” which is a complex event, defined as a composition of other simple or complex events together with conditions attached to these events. The situation in this case, called AlertTrack, is an “all” situation over two component events, TrackData and AlertTrigger, meaning that both of the component events must occur in order for the situation (and the corresponding rule) to be triggered. The two events in the situation use an arbitrary quantifier, referred to as “first,” and have the “retain” attribute set to “false,” meaning that the events are not to be retained by execution platform 34 after situation detection.
Processor 22 parses the rules defined by the user and generates corresponding run-time software code, at a code generation step 52. The processor also evaluates the worst-case execution duration for the code and presents the result to user 24, at an execution time computation step 54. For the sake of convenience and clarity of explanation, step 54 is shown in the figure and described hereinbelow as following step 52 (since the total execution duration depends on the benchmarked times that will be required to perform each of the operations in the run-time code). In practice, however, as will be explained below, each element of the situation expressed in the declarative language corresponds to certain operations in predefined abstract software classes. Thus, processor 22 may alternatively associate respective execution times with the expressions in the declarative language, and may use these execution times in computing the worst-case execution duration directly, before actually generating any code.
Processor 22 also generates a container 80 for holding sets of instances of each operator, which inherits from an abstract container class 78. Container 80 holds all active lifespans relating to the situation defined by the corresponding concrete class, and routes incoming events to the appropriate situation objects. For this purpose, for example, if the AlertTrackAll situation may be keyed using an ID attribute, it will ensure that the relevant incoming events are routed to an AlertTrackAll object with matching ID.
Events 84 are likewise defined as concrete classes, which implement an interface inherited from an abstract IEvent class 82.
The chain of inheritance of AlertTrackAll is shown by way of example in Tables II, III and IV in the Appendix below. The sample programs shown are written in the Java™ language, but the principles of the present invention may similarly be implemented in other suitable programming languages, as will be apparent to those skilled in the art. AlertTrackAll in Table IV inherits from AbstractAll in Table III, which in turn inherits from AbstractOperator in Table II. These classes import other classes for operations such as adding, composing and consuming events, which are omitted here for the sake of brevity. Such operations are commonly used in event processing, and their implementation will be apparent to those skilled in the art.
The code in Tables II and III contains iterative operations, such as the loops that are introduced by the following “FOR” statements:
Processor 22 maps the expressions in the declarative rule definition in Table I above to corresponding operations in AlertTrackAll. Since the AlertTrack situation is an “all” situation over two event types, the AlertTrackAll class extends AbstractAll, as explained above, and the “candidates” field in AltertTrackAll is an array of size 2, with two add methods, one for each event type. Because the two events in Table I use the “first” quantifier (an arbitrary attribute, used here for the sake of illustration), the corresponding adder and composer code objects are of the type FirstEventAdder and FirstEventComposer, which mimic the behavior of the “first” quantifier. An EventConsumer is included in the generated code to delete the events that were used to detect the situation, since the retain=“false” attribute indicates that the events are not to be retained after situation detection.
Returning now to
To derive the worst-case time estimate, processor 22 analyzes the basic behavior of the operators in the run-time code, such as the “compose” method in AbstractAll, and the “consume” method in AbstractOperator, as shown in Tables II and III below. The execution times of these operators will depend, in turn on the number of candidate events that are kept in memory, as well as on the execution times of the various event adders (such as FirstEventAdder), composers (such as FirstEventComposer), and consumers. These execution times may all be benchmarked in advance.
For iterative operations, processor 22 derive a bound on the number of iterations that will occur at run time, and multiplies this bound by the known execution time of a single iteration of the operation. The bound is typically derived by the processor by analyzing the definition of the rule itself in order to find a maximal number of situation components, which gives the bound on the number of iterations. For example, the rule may indicate the maximal number of simple events that will need to be processed by the software code in detecting an occurrence of the complex event that is the subject of the rule. Other examples of situation components from which the bound may be derived include the number of simultaneously open lifespans and the maximal number of event candidates (i.e., instances) for each event operand type.
In addition, processor 22 analyzes the execution times of rule-specific operations, such as the “createNotification” method in the AlertTrackAll class in Table IV. The createNotification method, for example, is composed of low-level Java primitives (array access, expression evaluation, etc.), which are also benchmarked in advance. The processor uses these benchmarks in computing the worst-case estimate for the specific method.
After having broken down the code (or possibly the corresponding declarative expressions, as explained above) into primitives and other operations that have been benchmarked in advance, processor 22 adds up the worst-case benchmark execution times for these primitives and operations (with multiplication as necessary for iterative operations) to get the total execution duration for the entire rule. For instance the createNotification method in AlertTrackAll (Table IV) consists of two array access operations, creation of a new object, and setting the values of three variables. The worst-case execution times of these primitives are summed to give the worst-case time that will be required to create a notification of a detected situation. Worst-case execution times for the other operations in AlertTrackAll may be determined in like manner.
The processor typically presents the result of the execution duration computation to the user on output device 26, at an acceptance step 56. If the user determines that the worst-case duration is within the acceptable limit to meet the real-time requirements of the application in question, the user approves the code. In this case, processor 22 outputs the code to run on platform 34 (typically after having compiled the source code into byte code or other executable form).
Alternatively, if the execution duration is longer than acceptable, user 24 may make appropriate changes in order to meet real-time requirements. For example, the user may simplify or otherwise revise the rules for faster operation, at a rule revision step 60. Processor 22 receives the revised rules at step 50 and repeats steps 52-56 in order to present the user with the new execution duration. As another alternative, the user may instruct the processor to repeat the computation of execution duration for a more powerful real-time platform, which will presumably run the code faster. Once the user has reached an acceptable result, the processor outputs the code at step 58.
Although the embodiments described above relate specifically to event processing, the principles of the present invention may similarly be applied in real-time applications of other types. It will thus be appreciated that the embodiments described above are cited by way of example, and that the present invention is not limited to what has been particularly shown and described hereinabove. Rather, the scope of the present invention includes both combinations and subcombinations of the various features described hereinabove, as well as variations and modifications thereof which would occur to persons skilled in the art upon reading the foregoing description and which are not disclosed in the prior art.
This application is a continuation-in-part of U.S. patent application Ser. No. 11/688,882, filed Mar. 21, 2007.
| Number | Date | Country | |
|---|---|---|---|
| Parent | 11688882 | Mar 2007 | US |
| Child | 13413672 | US |
