8:50 a.m.
Hi ,
I have been given an assignment to show case the situation where the
performance of a rule engine will be better than java code .
My first question is ; Is this possible ?
What I had done earlier was I sent an arraylist and I used the 'from'
clause , like Mark pointed out for the 'from' statement pure iteration
happens and the index is not created .
So what I have done now is create a scenario where I insert about 20,000
objects and have 20 rules (each rule has 2 alpha nodes ) . I do the same
with java code (if-elses) and the java code wins this competition hands
down .
Is there a breakthrough point where the rule engine performs as well as the
java code or even better ?
Appreciate it
Harsh
______________________________________________________________________
9:14 a.m.
A rule engine is java code, so well crafted java code is always going to
outperformance a generic rule engine - if you arrange all your caching
and indexing right. So I'm not sure what it is you are trying to prove?
If you wanted to prove that drools was faster than dump iteration and
lookup, try something that exploits the indexing. Create 10K people and
200 places. Assign the people randomly to different places - use a
String keyword to match the two. Then use the rule engine to find all
the people matching all the places and then try the same in java code.
Mark
Harsh Jetly wrote:
Hi ,
I have been given an assignment to show case the situation where the
performance of a rule engine will be better than java code .
My first question is ; Is this possible ?
What I had done earlier was I sent an arraylist and I used the 'from'
clause , like Mark pointed out for the 'from' statement pure iteration
happens and the index is not created .
So what I have done now is create a scenario where I insert about 20,000
objects and have 20 rules (each rule has 2 alpha nodes ) . I do the same
with java code (if-elses) and the java code wins this competition hands
down .
Is there a breakthrough point where the rule engine performs as well as the
java code or even better ?
Appreciate it
Harsh
______________________________________________________________________
_______________________________________________
rules-dev mailing list
rules-dev(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/rules-dev
4:32 p.m.
I'd say to really show the speed of rules (as well as
their expressive power) the rules should be a bit more
complex. This would show two things: 1) the indexing
of the rete handles ever more complex scenarios
automatically, and 2) it's just easier to express
complex scenarios in rules. Josh, you mentioned that
your rules only create alpha nodes. That tells me
you're not exploiting the full power a rule engine can
offer.
So, try this:
class Person {
char letter;
int number;
}
class Place {
char letter;
int number;
int matchCapacity;
}
Rules:
If a Person.letter == Place.letter, match them;
If a Person.number.isOdd() and place.number.isEven()
and they're matched, UNmatch them.
If a Person.number.isEven() and place.number.isOdd()
and they're matched, UNmatch them.
If a Place is over matchCapacity, throw out a random
matched Person.
***
Try adding more rules, like "Places with the same
letter can share People, but only if their numbers are
within 2."
You'll find that as you try writing the pure java
equivalent, adding rules, it will become 1) harder to
optimize the java version well, and/or 2) difficult to
express the java clearly and sussinctly.
GreG
--- Mark Proctor <mproctor(a)codehaus.org> wrote:
A rule engine is java code, so well crafted java
code is always going to
outperformance a generic rule engine - if you
arrange all your caching
and indexing right. So I'm not sure what it is you
are trying to prove?
If you wanted to prove that drools was faster than
dump iteration and
lookup, try something that exploits the indexing.
Create 10K people and
200 places. Assign the people randomly to different
places - use a
String keyword to match the two. Then use the rule
engine to find all
the people matching all the places and then try the
same in java code.
Mark
Harsh Jetly wrote:
> Hi ,
> I have been given an assignment to show case the
situation where the
> performance of a rule engine will be better than
java code .
>
> My first question is ; Is this possible ?
>
> What I had done earlier was I sent an arraylist
and I used the 'from'
> clause , like Mark pointed out for the 'from'
statement pure iteration
> happens and the index is not created .
>
> So what I have done now is create a scenario
where I insert about 20,000
> objects and have 20 rules (each rule has 2 alpha
nodes ) . I do the same
> with java code (if-elses) and the java code wins
this competition hands
> down .
>
> Is there a breakthrough point where the rule
engine performs as well as the
> java code or even better ?
>
>
> Appreciate it
>
> Harsh
>
>
>
______________________________________________________________________
> _______________________________________________
> rules-dev mailing list
> rules-dev(a)lists.jboss.org
> https://lists.jboss.org/mailman/listinfo/rules-dev
>
>
_______________________________________________
rules-dev mailing list
rules-dev(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/rules-dev
7:16 p.m.
1) First run your benchmark for at least a minute, before resetting it
and starting the time counter:
- drl's are probably compiled to java at runtime
- hotspot compiling takes a minute to warm up (in -server mode at least)
- java has a dog slow initialization phase, but it's the fastest
language on the planet once it's warmed up.
2) Your benchmark should at least run 10 minutes, anything less can
easily be affected by background tasks
3) After the first benchmark, double your data and check how much longer
it takes: that's your scalability.
Which program is better?
- program A: 10K rows give 10s and 20K rows give 40s
- program B: 10K rows give 25s and 20K rows give 50s
Program B is better if you speed limit is 100s,
because 40K rows will only take 100s on B (do the math yourself for
program A).
4) It's not about if and else, it's about nesting for/while loops.
Take some use cases where you need to nest for/while loops to be able to
implement your rules, then you 'll see a much better Big0 notation for
the rule engine (= much better scalability).
http://en.wikipedia.org/wiki/Big_O_notation
With kind regards,
Geoffrey De Smet
Harsh Jetly schreef:
Hi ,
I have been given an assignment to show case the situation where the
performance of a rule engine will be better than java code .
My first question is ; Is this possible ?
What I had done earlier was I sent an arraylist and I used the 'from'
clause , like Mark pointed out for the 'from' statement pure iteration
happens and the index is not created .
So what I have done now is create a scenario where I insert about 20,000
objects and have 20 rules (each rule has 2 alpha nodes ) . I do the same
with java code (if-elses) and the java code wins this competition hands
down .
Is there a breakthrough point where the rule engine performs as well as the
java code or even better ?
Appreciate it
Harsh
______________________________________________________________________
_______________________________________________
rules-dev mailing list
rules-dev(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/rules-dev
5984
days inactive
5984
days old
3 comments
4 participants
participants (4)
-
Geoffrey De Smet -
Greg Barton -
Harsh Jetly -
Mark Proctor