Property Reactive RuleML 2013

Language and
System Ergonomics
http://www.slideshare.net/MarkProctor/property-reactive-ruleml-2013
Saturday, 13 July 13

Extending an Object-Oriented RETE
Network with fine-grained
Reactivity to Property Modifications
Mark Proctor, Mario Fusco and David Sottara

Agenda
The Problem
Property Reactive
The technique
Related Work
The Implementation
Benchmarking
Conclusion

The Problem
Loop Control

The problem
Reactive rule based systems are hard to
write

Too Much!!!!
Reactive rule based systems are hard to
write

Reactive Rule
rule <rule_name>
<attribute><value>
when
<conditions>
then
<actions>
end

Patterns
Person(age >= 18)
ﬁeld name restriction
constraintobject type
pattern

CashFlow Ruleselect * from
AccountPeriod ap,
Account acc,
Cashflow cf
where cf.type == CREDIT and
acc.accountNo == cf.accountNo
cf.date >= ap.start and cf.date <= ap.end
rule “increase balance for AccountPeriod Credits”
when
ap : AccountPeriod()
acc : Account()
cf : CashFlow( type == CREDIT,
accountNo == acc.accountNo,
date >= ap.start && <= ap.end )
then
acc.balance += cf.amount;
end
acc.balance += cf.amount

Loop Problem
rule “Salary award for min 2 years service” when
e : Employee( lengthOfService > 2 )
then
modify( e ) { setSalary( e.getSalary() * 1.05 ) };
end

Loop Problem
rule “Salary award for min 2 years service” no-loop
when
then
end

Loop Problem
rule “Salary award for min 2 years service” no-loop when
then
end
rule “Salary award for min 8 years service” no-loop when
then
end

Loop Problem
not SalaryMin2Years( employee == e )
then
insert ( new SalaryMin2Years(e) );
end
then
end

Loop Problem
rule “Year End” when
d : ChangeDate( )
e : Employee( )
then
modify( e ) { lengthOfService(
d.getYear() - e.getStartYear() ) };
end
then
end

Refraction
This term comes from the neurobiological
observation of a refractory period for a neuron,
which means that the neuron is not able to fire
immediately without first going through a
relaxation process.
In a similar way, OPS5 will not allow the same
instantiation in the conflict set from firing twice
in a row. This prevents the inference engine from
entering into an infinite loop.

W3C RIF Refraction
Refraction
When a rule instance is fired, it is removed
from the conflict set (and thus will not be
created again even its condition part
remains true), unless one of the objects in its
condition part is modified again. In the later
case, the repeatability concept determines
how the rule instance is treated

W3C RIF Refraction
Repeatability
After the execution of a rule instance, the
rule instance is removed from the conflict
set by the refraction. Later on, if one of the
objects in the condition part is modified and
if the rule evaluates to true, the
repeatability controls whether if the rule
instance can be created again.

Loop Problem (Refraction)
rule “Salary award for min 2 years service”
repeatable false when
then
end
rule “Salary award for min 8 years service”
repeatable false when
then
end

AAAAAAhhhhhhhhhh

Property Reactive
The Technique

Annotate Class
@PropertyReactive
public class Employee {
int salary;
int lengthOfService
// getters and setters below
}

Loop Problem Fixed
then
end
then
end

@Watch
e : Employee( salary < 1000, lengthOfService > 2 )
@Watch( !salary )
then
end

@Watch
rule “Record Salary Changes” when
e : Employee( ) @Watch( salary )
then
insert( new SalaryChange( e, e.getSalary() );
end

@Watch
@Watch( salary, lengthOfService, age )
@Watch( * )
@Watch( !* )
@Watch( *, !salary )
@Watch( !*, salary )

Good Form
Good Function

Property Reactive
Related Work

Related Work
CLIPS COOL
Uses Triples for properties
Property Reactivity is just a useful side effect,
not an intention.
No @Watch like capability
Jess
Slot Specific
no literature on implementation
No @Watch like capability

Related Work
YES/OPS
“New Trigger Conditions”
Simple @Watches with “!” symbol
No literature on implementation

Property Reactive
The Implementation

Class
@PropertyReactive
public class Bar {
int a; // 1
int b; // 2
int c; // 4
int d; // 8
int e; // 16
int f; // 32
// getters and setters below
}

Propagation Masks
@PropertyReactive
public class Bar {
int a; // 1
int b; // 2
int c; // 4
int d; // 8
int e; // 16
int f; // 32
}
modify ( bar ) { a = 1 }
// 000001
modify ( bar ) { a = 1, c = 1 }
// 000101
modify ( bar ) { a = 1, c = 1, f = 1 }
// 100101

Network Masks
rule R1 when
Foo( $v : v )
bar : Bar( c >= 1, a >= 1, e >= $v ) then ... end
Bar
a => 1
c => 1
e => V
b1
a1
a2
Foo
declared : 000100
inferred : 010101
declared : 000001
inferred : 010101
declared : 010000
inferred : 010101
modify ( bar ) { a = 1, c = 1 }
// 000101
modify ( bar ) { b = 1, d = 1 }
// 010010

Network Masks
rule R1 when
Foo( $v : v )
Bar( c >= 1, a >= 1, e >= $v )
rule R2 when
Foo( $v : v )
Bar( c >= 1, d >= 1, b >= $v )
Bar
a => 1
c => 1
d => 1
e => V b => V
a1
a2 a3
Network
Share
Here
declared : 001000
inferred : 011111
declared : 000001
inferred : 010101
declared : 010000
inferred : 010101
declared : 001000
inferred : 001110
declared : 000010
inferred : 001110
b1 b2

Network Masks
rule R1 when
Foo( $v : v )
Bar( c >= 1, a >= 1, e >= $v )
rule R2 when
Foo( $v : v )
Bar( c >= 1, d >= 1, b >= $v )
rule R3 when Dummy( )
Bar( c >= 1 ) @Watch( f, d, !c )
Bar
a => 1
c => 1
d => 1
e => V b => V
@watch(f, d, !c)
b1 b2 b3
a1
a2 a3

Network Masks
Bar
a => 1
c => 1
d => 1
e => V b => V
a1
a2 a3
Network
Share
Here
declared : 001000
inferred : 111111
declared : 000001
inferred : 010101
declared : 010000
inferred : 010101
declared : 001000
inferred : 001110
declared : 000010
inferred : 001110
b1 b2
@watch(f, d, !c)
b3
declared : 101000
inferred : 101000

Property Reactive
Benchmark

Hardware
i7-2820QM@2.30GHz Quad core CPU
with HyperThreading
8Gb of RAM,
OpenJDK 1.7
Ubuntu Quetzal 64bit operating system

Classes
A
int a1, int b1
B
int b2, int b2

Benchmark #1
rule R0 when
$a: A( $a1 : a1 < 10 )
then
modify( $a ) { setA2( $a1 + 1 ) };
end
rule R0 no-loop when
$a: A( $a1 : a1 < 10 )
then
modify( $a ) { setA2( $a1 + 1 ) };
end
insert 1mill A
Initial a1, a2 set to 1
No-loop
2.275±0.080s
Property Reactive
2.265 ± 0.047s
Gain
0.44%

Benchmark #4
rule R3 when
a: A( a1 < 10 )
b: B( b1 < a.a1 )
...
x: X( x1 < w.w1, x2 > a.a2 )
then
modify( a ) { setA2( c.getC2() + 1 ) };
end

Benchmark #4 Results
rule R3 when
a: A( a1 < 10 )
b: B( b1 < a.a1 )
...
x: X( x1 < w.w1, x2 > a.a2 )
then
modify( a ) { setA2( c.getC2() + 1 ) };
end

Conclusion

Conclusion - Achieved
Enabled and Disabled at a Class level for flexibility
Complimentary and additional to RIF Refraction and
Repeatable, adding finer grained control.
@Watch provides even further declarative control.
Keeps rules clean.
Not Polluted with control logic.
Not any slower, and can give increased gains, by avoiding wasted
join evaluations.
Cost pushed to compile time, works with dynamic rules addition
and removal.
Good Form, Good Function

Conclusion - Future Work
@Watch
Can we push all or part of the @Watch higher up the alpha
network
Discriminates earlier, better performance
Further flexibility to control propagations based on rising and
falling edges
onMatch, onReMatch, onUnmatch

Zen-like Calmness

Property Reactive RuleML 2013

Recommended

Recommended

More Related Content

Similar to Property Reactive RuleML 2013

Similar to Property Reactive RuleML 2013 (20)

More from Mark Proctor

More from Mark Proctor (20)

Recently uploaded

Recently uploaded (20)

Property Reactive RuleML 2013