WO2009104950A1

WO2009104950A1 - Network unit and method for expression evaluation

Info

Publication number: WO2009104950A1
Application number: PCT/NL2008/050102
Authority: WO
Inventors: Frederik Hugo Zwaal
Original assignee: Telefonaktiebolaget Lm Ericsson (Publ)
Priority date: 2008-02-21
Filing date: 2008-02-21
Publication date: 2009-08-27

Abstract

Method and network unit (2) for providing a service in a communication network (1) and communicat ing with context sources (5a - 5f) which provide input values for a triggered expression evaluation. The network node (2) comprises a FIFO queue (7) and is further arranged to insert a generated internal trigger in the FIFO queue (7), to invoke one or more internal nodes (6) associated with a n internal trigger which is on top of the FIFO queue (7), and for each of the one or more internal nodes (6), to determine whether descendant nodes (5, 6) of the invoked internal node (6) have any p ending internal triggers, and if so, inserting a new internal trigger for re-evaluation of the internal node (6) on the FIFO queue (7), and if not, re-evaluating the expression of the internal node (6).

Description

Network unit and method for expression evaluation

Field of the invention

The present invention relates to a network unit and a method for expression evaluation, which is used in many technical applications, such as context source evaluations in mobile network based services, but also in sensor network applications (e.g. in automotive industry) or logic circuitry. More in particular, the present application relates to a network unit and a method for triggered expression evaluation upon a change to an input value.

Prior art

Expression evaluation is normally done in a top-down fashion. When the value of an expression needs to be evaluated, all operands are evaluated left-to-right in a depth- first manner. Triggered expression evaluation, however, is performed bottom-up. This means that an expression is re-evaluated whenever the value of one of its operands changes. Since the expression can be an operand itself, the changes will propagate towards the top -most expression(s). Triggered expression evaluation is typically implemented by having an operand trigger its parent (higher level) expression(s), which then re-evaluate their value(s) and in turn trigger their parent(s) if a change is detected.

Summary of the invention

In a method according to the prior art, such an implementation exhibits the following problem, since only one parent expression can be re-evaluated at a certain moment. When multiple parallel paths from an operand exist toward the same ancestor, the triggers (for the same change) along these different paths might cause a temporarily incorrect expression result.

The present invention seeks to provide a network unit for a communication network and a method which eliminates this type of problem during triggered expression evaluation.

According to the present invention, a network unit for a communication network is provided, the network unit providing a service in the communication network and arranged to communicate with context sources which provide input values for a triggered expression evaluation, and to provide a network service to further devices (such as communication devices) connected to the communication network based on the result of the triggered expression evaluation, in which the network unit is further arranged to execute the triggered expression evaluation, the triggered expression evaluation comprising the evaluation of nodes in an expression graph, the expression graph having multiple nodes interconnected by one or more triggers from a descendent node to a parent node, the nodes being an external node or an internal node, an external node comprising an input value and providing an external trigger upon a change of the input value, an internal node comprising an expression on one or more operands, each of the one or more operands representing a trigger value received from a descendent node, and each internal node providing an internal trigger upon a change of the expression result, in which the network node comprises a FIFO queue and is further arranged to insert a generated internal trigger in the FIFO queue, to invoke one or more internal nodes associated with an internal trigger which is on top of the FIFO queue, and for each of the one or more internal nodes, to determine whether descendant nodes of the invoked internal node have any pending internal triggers, and if so, inserting a new internal trigger for re-evaluation of the internal node on the FIFO queue, and if not, reevaluating the expression of the internal node. This allows to prevent possible problems with triggered expression evaluation as described above, while only a single, simple and cost-effective FIFO queue (first-in- first-out) is needed.

In an embodiment, the network unit is further arranged to insert a generated internal trigger in the FIFO queue before invoking the one or more internal nodes. By having the FIFO queue filled by the sending node, an efficient expression evaluation can be implemented using as little processing resources as possible. In an alternative embodiment, the network unit is further arranged to insert a generated internal trigger in the FIFO queue after reception by the one or more internal nodes. In most circumstances this will result in more internal triggers being generated, but still an effective and efficient implementation is possible.

Advantageously, the network unit is a processing node in an intelligent network. In such intelligent networks, many services are provided to users of the intelligent network which are based on triggered expression evaluation. In a further embodiment, the communication network is a mobile telecommunications network. In many present day (mobile) telecommunications networks, intelligent services are offered.

In a further aspect, the present invention relates to a method for obtaining an evaluation result of a triggered expression evaluation upon a change to an input value, the triggered expression evaluation comprising the evaluation of nodes in an expression graph, the expression graph having multiple nodes interconnected by one or more triggers from a descendent node to a parent node, the nodes being an external node or an internal node, an external node comprising an input value and providing an external trigger upon a change of the input value, an internal node comprising an expression on one or more operands, each of the one or more operands comprising a trigger value received from a descendent node, and each internal node providing an internal trigger upon a change of the expression result, in which the method comprises inserting a generated internal trigger in a FIFO queue, invoking one or more internal nodes associated with an internal trigger which is on top of the FIFO queue, and for each of the one or more internal nodes, determining whether descendant nodes of the invoked internal node have any pending internal triggers, and if so, inserting a new internal trigger for re-evaluation of the internal node on the FIFO queue, and if not, reevaluating the expression of the internal node. A generated internal trigger may be inserted in the FIFO queue before invoking the one or more internal nodes, or alternatively, a generated internal trigger is inserted in the FIFO queue after reception by the one or more internal nodes. Again, the method may be advantageously applied for a service provided in a communication network.

In an even further aspect, the present invention relates to a processing circuit comprising one or more input units, an output unit, and logic circuitry connected to the one or more input units and output unit, in which the logic circuitry implements a set of logical expressions for triggered expression evaluation using the input units to obtain input values and the output unit to provide an evaluation result, further comprising a logic circuitry control unit with a FIFO queue for controlling the order of expression evaluation in the set of expressions according to any of the present method embodiments. Short description of drawings

The present invention will be discussed in more detail below, using a number of exemplary embodiments, with reference to the attached drawings, in which

Fig. 1 shows a schematic diagram of a communication network in which the present invention may be embodied;

Fig. 2 shows a graph representation of an expression evaluation example;

Fig. 3 shows a part of the graph of Fig. 2 illustrating a multipath example;

Fig. 4a, 4b and 5 shows the graph representation of Fig. 2 in which various stages of the present embodiments are illustrated; Fig. 6 shows a schematic diagram of an implementation of the present invention in a processing circuit.

Detailed description of exemplary embodiments

The present invention embodiments, as described in the annexed claims, are clarified below using an example of an expression evaluation for a mobile network service. A heart monitoring system or service may e.g. be implemented as a service in an intelligent (mobile) communication network 1 , where a heart patient is monitored (using sensors 10, a sensor interface 11, and a (mobile) communication device 12) and a caretaker needs to be notified as soon as an abnormal heart condition occurs (e.g. using a mobile communication device 15, 16). This is illustrated schematically in Fig. 1 , which shows the communication network 1 comprising an intelligent network unit 2 which executes an intelligent network service (service layer execution). The patient is shown with a number of sensors 10, which are connected to the mobile communication device or mobile station 12 using a sensor interface 11. On the other side, caretakers are shown (e.g. a nurse and a doctor) with associated mobile stations 15, 16. The mobile stations 12, 15, 16 may be provided with location devices, such as GPS receivers, which allow the mobile station to determine its position. As an alternative, the network 1 is arranged to determine the locations of the mobile stations 12, 15, 16, e.g. using radio triangulation. The functioning of the monitoring system, which may e.g. be implemented in the intelligent network unit 2 in the mobile (tele)communications network 1 , can be illustrated using a few simple expressions, the function being implemented by evaluating the expressions: HeartrateAlarm := Patient.Heartrate > 150; BloodpressureAlarm := Patient.Bloodpressure > 100;

Alarm := BloodpressureAlarm OR HeartrateAlarm; MajorAlarm := BloodpressureAlarm AND HeartrateAlarm;

MinorAlarm := Alarm AND NOT MajorAlarm;

NurseDistance := DIST(Patient.Location, Nurse.Location);

NurseCanHelp := Nurse. Available AND (NurseDistance < 10);

NurseCannotHelp := NOT NurseCanHelp OR NOT MinorAlarm;

NotifyNurse := MinorAlarm AND NurseCanHelp;

NotifyDoctor := Alarm AND Doctor .Available AND NurseCannotHelp;

The input values used in the monitoring system (e.g. Patient.HeartRate) can be seen as context sources 5 for the service implemented in the intelligent network service node 2.

In plain words, the above set of expressions results in that in case of a minor alarm (one heart parameter over threshold) a nurse is notified when available and within reasonable distance. In case of a major alarm (both heart parameters over threshold) or when a nurse cannot help, a doctor is notified when available.

The above set of expressions can also be represented visually in a graph, as shown in Fig. 2. (Note that in triggered expression evaluation, evaluation is bottom-up (right to left in Fig. 2), hence the arrows which indicate the trigger direction).

Each of the expressions in the set of expressions to be evaluated (and possible intermediate expressions) are indicated by internal nodes 6a-6o, which receive triggers (one way branches between a internal nodes 6a-6o). Each internal node 6a-6o thus represents a single expression, which is a (logical, Boolean, ...) operation on one or more operands (the received triggers). The internal node 6a-6o possibly provides a trigger (i.e. an internal trigger) for a higher level (parent) node 6d-6o in the graph. The top-most internal nodes 6n and 6o not providing a further internal trigger (i.e. not having any parent nodes in graph terminology) are the results of the expression evaluation (e.g. Notify Nurse and Notify Doctor in the example of Fig. 2). It is noted that the top-most internal nodes 6n and 6o of course are the final results from the triggered expression evaluation, and of course when the value of such a top-most node 6n, 6o changes, this change is noted and sent to the application providing the service in the network 1.

The input values for the set of expressions (the external changing variables, or context sources), are indicated as right-most nodes, or external nodes 5a-5f in the graph of Fig. 2, e.g. the Patient.Heartrate. These external nodes 5a-5f are trigger based, and can provide an external trigger when an input value changes. Sending an external trigger to an internal node 6a-6o equals to the effect that a parent internal node 6d-6o is invoked.

Triggered expression evaluation is typically implemented by having an operand trigger its parent (higher level) expression(s), which then re-evaluate their value(s) and in turn trigger their parent expression(s) if a change is detected. Since only one parent can be re-evaluated at a certain moment, such an implementation exhibits the following problem.

When multiple parallel paths from an operand (trigger value) toward the same ancestor (parent node) exist, the triggers (for the same change) along these different paths might cause a temporarily incorrect expression result, as indicated in the following example.

In the heart monitoring example, two parallel paths exist between the Alarm node 6d and NotifyDoctor node 6n. These paths are visualized in Fig. 3 (for clarity, the rest of the expression graph has been omitted).

Consider the situation in which the Patient.Heartrate (external node 5b) exceeds the threshold (150) and a HeartrateAlarm is detected in internal node 6a and both the doctor and the nurse are available (external nodes 5 a and 5f). The HeartrateAlarm node 6a is re-evaluated (to true) and its parent nodes (Alarm node 6d and MajorAlarm node 6e) are triggered.

Alarm node 6d and MajorAlarm node 6e both are re-evaluated (sequence does not matter here, Alarm changes to true and Major Alarm stays false) and the Alarm change is detected and its parents (NotifyDoctor node 6n and MinorAlarm node 6i) are triggered. NotifyDoctor node 6n and MinorAlarm node 6i both are re-evaluated. MinorAlarm node 6i becomes true and its parent nodes (NotifyNurse node 6o and a nameless NOT node 6k) are triggered. The NotifyDoctor node 6n also becomes true so the doctor is notified. NotifyNurse node 6o and the nameless NOT node 6k both are re-evaluated. The nameless NOT node 6k becomes true and its parent (NurseCannotHelp node 6m) is triggered. The NotifyNurse node 6o also becomes true so the nurse is notified.

NurseCannotHelp node 6m is re-evaluated and its parent (NotifyDoctor node 6n) is triggered so that it is re-evaluated. The NotifyDoctor node 6n becomes false again, which is the correct value given the current input values.

However, the damage is already done: the doctor has already been notified, while only the nurse should have been notified.

Note that the above example only illustrates a problem that can occur. The problem will occur in any expression graph that has parallel paths between two nodes, in which one change causes different reactions in the ancestor.

According to an embodiment of the present invention, whenever an internal node 6a-6o is re-evaluated and a change of the expression result is detected, an internal trigger is scheduled in a FIFO queue 7 (e.g. by storing a value representing the trigger in the FIFO queue 7). When the (internal) trigger arrives at the front of the FIFO queue 7, it is executed and all parent nodes 6d-6o of that specific internal node are invoked. Before re-evaluating themselves, each parent node 6d-6o will first check all its descendent nodes 6a-6o for pending internal triggers in the FIFO queue 7. If any of the parent node's descendent nodes 6a-6o have an internal trigger pending, then no re- evaluation takes place for the specific parent node 6d-6o. Instead, the parent node 6d- 6o will schedule a new trigger (for itself) in the FIFO queue 7. When the parent node 6d-6o receives its own trigger, it will again check its descendent nodes 6a-6o. Eventually, none of them will have an internal trigger pending, upon which the parent node 6d-6o finally re-evaluates itself. Again, this may result in a further internal trigger(s) to (a) further parent node(s) 6d-6o, which are then input in the FIFO queue 7. In the following, the term 'trigger' is used in the sense of an internal trigger, and the term 'external trigger' is used to denote a change in an input value (external nodes 5) The present invention embodiments are described in more detail below using the same example situation as described in relation to Fig. 1-3. The HeartrateAlarm node 6a is re-evaluated (after receiving an external trigger from external node 5b (PatientHeartrate) and the resulting trigger (a) is scheduled in the FIFO queue 7. When this trigger is on top of the FIFO queue 7, it will cause internal node 6a (Heartrate Alarm) to invoke its parent nodes Alarm (node 6d) and MajorAlarm (node 6e). The trigger (a) will be received by the nodes Alarm and MajorAlarm (internal nodes 6d and 6e) in no particular order. However, it will be received by both nodes 6d, 6e before any other trigger is handled by these nodes. It is therefore irrelevant in which order it is received.

The first trigger (a) is executed and received by the nodes Alarm and MajorAlarm (internal nodes 6d, 6e). Node 6d (Alarm) queries its descendent nodes, being the HeartrateAlarm (internal node 6a) and BloodpressureAlarm (internal node 6b) which in turn query their descendent nodes (Patient.Heartrate external node 5b and Patient.Bloodpressure external node 5c)]. Since none of them have any pending triggers, it is allowed that internal node 6d (Alarm) is re-evaluated. As a change has occurred, this internal node 6d is ready to send a trigger (b) to its parent nodes 6i (Minor Alarm) and 6n (Notify Doctor), by putting the trigger (b) in the FIFO queue 7. In this example, it is assumed that a parent node does not know whether a descendent node is an internal or external node and the parent node will check all descendent nodes for pending internal triggers. An external node 5a-5f will always answer negatively to this query. In a further design option, this knowledge may be present with a parent node, and the parent node only checks its descendant nodes which are internal nodes. MajorAlarm internal node 6e also receives the trigger and therefore also queries its descendent nodes (internal nodes 6a, 6b, and external nodes 5b, 5c). Since none of them have any pending triggers, the internal node 6e (MajorAlarm) is also re-evaluated. Since no change is detected, no resulting trigger is scheduled. At this point the trigger (a) is removed from the FIFO queue 7.

The above is illustrated graphically in the graphs shown in Fig. 4a and 4b. The next trigger (b) (which is now on top of FIFO queue 7) is executed and invokes the NotifyDoctor node 6n and MinorAlarm node 6i. Either one of them can receive the trigger (b) first. In case NotifyDoctor node 6n receives the trigger (b) first, it queries its descendents (among which MinorAlarm node 6i). Since there is a pending trigger (b) for MinorAlarm node 6i, NotifyDoctor node 6n will schedule a trigger (c) for itself (by inserting trigger (c) on the FIFO queue 7) and do nothing further. Next MinorAlarm node 6i receives the trigger (b), performs the query, is re-evaluated (as no triggers are pending for its associated descendent nodes) and schedules the resulting trigger (d) in the FIFO queue 7. This point is shown graphically in Fig. 5. Now again, the NotifyDoctor node 6n again queries its descendent nodes (as trigger (c) is on top of the FIFO queue, but still, the pending trigger (d) for the internal node 6k prevents it from being executed, and again a new trigger (e) for the NotifyDoctor node 6n is put in the FIFO queue 7. Trigger (d) is now on top of the FIFO queue, and the internal node 6k is allowed to be re-evaluated (as no descendent nodes exist for which triggers are pending). The NotifyDoctor node 6n will keep on scheduling a new trigger for itself in the FIFO queue until NurseCannotHelp node 6m has been re-evaluated. Eventually the NotifyDoctor node 6n will be allowed to be re-evaluated in a correct manner.

In case MinorAlarm node 6i receives the trigger (b) first, it queries its descendent nodes 6d, 6g (and 6e, 6a, 6b, 5b, 5c) and finds that none of them have any pending triggers. The expression of MinorAlarm node 6i is re-evaluated and a resulting trigger (now (c)) is scheduled. The NotifyDoctor node 6n then receives the trigger (b), performs the query for its descendent nodes and detects that one of its descendents (the nameless NOT node 6k) has a pending trigger (c). Consequently, NotifyDoctor node 6n then schedules a trigger (d) for itself on FIFO queue 7 and halts further action. In a similar manner, the triggers on the FIFO queue 7 are handled (resulting in a number of new triggers for NotifyDoctor node 6n on FIFO queue 7), until eventually the NotifyDoctor node 6n is re-evaluated in a correct manner.

These embodiments using a FIFO queue 7 is different from the schedule as described in pending application PCT/NL2007/050309 of applicant, in which a priority queue is used for scheduling internal triggers. When a trigger is detected to be received 'too early', no re-evaluation is performed of the related internal node 6a-6o. Instead, a new trigger for the internal node 6a-6o is scheduled at the end of the FIFO queue 7. The new trigger will cause the specific internal node 6a-6o to re-evaluate eventually.

In the embodiments described above, triggers are scheduled on the sending side, rather than on the receiving side. That means that one change (of an internal node 6a- 6o) causes exactly one trigger that will be received by all parent nodes 6d-6o. A next trigger is only executed after all parent nodes 6d-6o have received the previous trigger.

This alternative solution is somewhat less efficient. Especially checking the descendent nodes 6a-6o costs more processing power. It may also require more triggers to be initiated and put in the FIFO queue 7. The main advantage of the embodiments of the present application is the use of FIFO queue 7, which is simpler (and less costly) to implement compared to a priority queue.

In further embodiments, scheduling can be performed for the reception of the trigger by parent (internal) nodes 6d-6o. This will not change drastically change the workings of the embodiments as described above, however, it will result in more triggers in the FIFO queue 7.

In the pending application PCT/NL2007/050309, as mentioned above, it is described that also the external nodes 5a-5f use a queue (e.g. a FIFO queue) to store external triggers (changes in input values) as they occur. In the present invention, this queue is not taken into account when looking for pending triggers of descendant nodes, and it is a separate mechanism. In a further embodiment, this queue can be combined with the FIFO queue 7 of the present invention, however, further measures must be taken to be able to discern between external and internal triggers, e.g. by flagging the triggers in the queue 7. It will be understood that the present invention may be applied in every implementation of triggered expression evaluation involving (nested) internal expressions and external input values (context sources), such as the service application in a telecommunication network as described above. A further example of an implementation is e.g. complex sensor applications, in which multiple sensors are being monitored, and the values thereof are being evaluated using an expression evaluation. Implementations can e.g. be in industrial control systems, or automotive applications. Fig. 6 shows a schematic diagram of an implementation of the embodiments of the present invention in a processing circuit, e.g. as part of a network unit 2 in communication network 1. The processing circuit comprises one or more input units 24 and an output unit 25. Logic circuitry 23 is connected to the one or more input units 24 and output unit 25, which logic circuitry 23 implements a set of logical expressions for expression evaluation. The input units 24 are used to obtain input values (from the context sources or external nodes 5a-5f, see Fig. 2) and the output unit 25 is used to

Claims

provide an evaluation result, e.g. to start a call to a mobile station 15 or 16 in a specific situation. A logic circuitry control unit 26 is provided for controlling the order of expression evaluation in the set of expressions according to one of the method embodiments as described above. The logic circuitry control unit 26 may be provided with the FIFO queue 7 as described in relation to the present invention embodiments above.The implementation of the method embodiments of the present inventions may be accomplished in hardware (e.g. (programmable) logic circuitry 23), in software (processor executable instructions, ranging from assembler code to high level programming languages), or combinations thereof. CLAIMS

1. Network unit for a communication network (1), the network unit (2) providing a service in the communication network (1) and arranged to communicate with context sources (5a-5f) which provide input values for a triggered expression evaluation, and to provide a network service to further devices (12, 15, 16) connected to the communication network (1) based on the result of the triggered expression evaluation, in which the network unit (2) is further arranged to execute the triggered expression evaluation, the triggered expression evaluation comprising the evaluation of nodes (5, 6) in an expression graph, the expression graph having multiple nodes (5, 6) interconnected by one or more triggers from a descendent node to a parent node, the nodes being an external node (5) or an internal node (6), an external node (5) comprising an input value and providing an external trigger upon a change of the input value, an internal node (6) comprising an expression on one or more operands, each of the one or more operands representing a trigger value received from a descendent node (5, 6), and each internal node (6) providing an internal trigger upon a change of the expression result, in which the network node (2) comprises a FIFO queue (7) and is further arranged to insert a generated internal trigger in the FIFO queue (7); invoke one or more internal nodes (6) associated with an internal trigger which is on top of the FIFO queue (7); and for each of the one or more internal nodes (6), determine whether descendant nodes (5, 6) of the invoked internal node (6) have any pending internal triggers, and if so, inserting a new internal trigger for re-evaluation of the internal node (6) on the FIFO queue (7), and if not, re-evaluating the expression of the internal node (6).

2. Network unit according to claim 1, in which the network unit (2) is further arranged to insert a generated internal trigger in the FIFO queue (7) before invoking the one or more internal nodes (6).

3. Network unit according to claim 1, in which the network unit (2) is further arranged to insert a generated internal trigger in the FIFO queue (7) after reception by the one or more internal nodes (6).

4. Network unit according to any one of claims 1-3, in which the network unit (2) is a processing node in an intelligent network (1).

5. Network unit according to any one of claims 1-4, in which the communication network (1) is a mobile telecommunications network.

6. Method for obtaining an evaluation result of a triggered expression evaluation upon a change to an input value, the triggered expression evaluation comprising the evaluation of nodes in an expression graph, the expression graph having multiple nodes interconnected by one or more triggers from a descendent node to a parent node, the nodes being an external node or an internal node, an external node comprising an input value and providing an external trigger upon a change of the input value, an internal node comprising an expression on one or more operands, each of the one or more operands comprising a trigger value received from a descendent node, and each internal node providing an internal trigger upon a change of the expression result, in which the method comprises inserting a generated internal trigger in a FIFO queue; invoking one or more internal nodes associated with an internal trigger which is on top of the FIFO queue; and for each of the one or more internal nodes, determining whether descendant nodes of the invoked internal node have any pending internal triggers, and if so, inserting a new internal trigger for re-evaluation of the internal node on the FIFO queue, and if not, reevaluating the expression of the internal node.

7. Method according to claim 6, in which a generated internal trigger is inserted in the FIFO queue before invoking the one or more internal nodes.

8. Method according to claim 6, in which a generated internal trigger is inserted in the FIFO queue after reception by the one or more internal nodes.

9. Method according to any one of claims 6-8, in which the method is applied for a service provided in a communication network (1).

10. Processing circuit comprising one or more input units (24), an output unit (25), and logic circuitry (23) connected to the one or more input units (24) and output unit (25), in which the logic circuitry (23) implements a set of logical expressions for triggered expression evaluation using the input units (24) to obtain input values and the output unit (25) to provide an evaluation result, further comprising a logic circuitry control unit (26) and a FIFO queue (7) for controlling the order of expression evaluation in the set of expressions according to the method of any one of the claims 6- 9.