[rules-users] Drools-Guvnor – question about build and deploy packages

2011-04-19 Thread Patricia Bogoevici

I am using Drools-Guvnor 5.1 release in
an enterprise application. The rules created are separated per
packages, and for each package there is a snapshot package called
LATEST. The KnowledgeAgent polls the snapshot packages
to get the latest data and load into the rule engine. Whenever there is a new 
rule, or
updates to an existing one, the application triggers the process of
re-creating the package snapshot: builds all the rules within the
package, and creates a new snapshot for the package.



The main problem with this approach is
that the time to build the package rules, increases quite a lot as
the number if rules gets higher. This creates a serious performance
hit in the real-time app whenever there is a change to the rules.



I sneaked a bit to the source code, and
noticed that when build package is called, Guvnor builds a new binary for all 
the rules within a
package even though not all of them are modified. Would it be possible to 
incrementally create/update the package binary? This would speed up
things a lot when the package has lots of rules but only one rule
changes at the time.



What is the best approach for creating
the package snapshots? The approach we've taken is to build all the
rules within a package into one snapshot, and we ran into this performance 
issue. 




Any ideas/suggestions is much
appreciated.



Thanks,
Patricia___
rules-users mailing list
rules-users@lists.jboss.org
https://lists.jboss.org/mailman/listinfo/rules-users


Re: [rules-users] Drools-Guvnor ­ question about build and deploy packages

2011-04-19 Thread David Faulkner
Patricia,

My understanding (which is certainly open to being corrected) is that in 
general there is no way to do an incremental compilation of rules. The entire 
package is analyzed together and significant optimizations are performed to 
combine common items between rules (which is one of the big reasons why the 
engine executes so well!). So, generally, what you are doing is the best 
practice.

When you say that you are experiencing a performance hit, are you talking about 
a delay in seeing the updates appear in your production application, or 
something else? Generally, the compilation is a one-time step, and even during 
compilation your enterprise application that is actually using the rules should 
continue to perform quite reasonably, since the compilation is going on in a 
separate application.

David

From: Patricia Bogoevici 
patriciabogoev...@yahoo.commailto:patriciabogoev...@yahoo.com
Reply-To: Rules Users List 
rules-users@lists.jboss.orgmailto:rules-users@lists.jboss.org
Date: Tue, 19 Apr 2011 10:45:59 -0500
To: Rules Users List 
rules-users@lists.jboss.orgmailto:rules-users@lists.jboss.org
Subject: [rules-users] Drools-Guvnor – question about build and deploy packages



I am using Drools-Guvnor 5.1 release in an enterprise application. The rules 
created are separated per packages, and for each package there is a snapshot 
package called LATEST. The KnowledgeAgent polls the snapshot packages to get 
the latest data and load into the rule engine. Whenever there is a new rule, or 
updates to an existing one, the application triggers the process of re-creating 
the package snapshot: builds all the rules within the package, and creates a 
new snapshot for the package.


The main problem with this approach is that the time to build the package 
rules, increases quite a lot as the number if rules gets higher. This creates a 
serious performance hit in the real-time app whenever there is a change to the 
rules.


I sneaked a bit to the source code, and noticed that when build package is 
called, Guvnor builds a new binary for all the rules within a package even 
though not all of them are modified. Would it be possible to incrementally 
create/update the package binary? This would speed up things a lot when the 
package has lots of rules but only one rule changes at the time.


What is the best approach for creating the package snapshots? The approach 
we've taken is to build all the rules within a package into one snapshot, and 
we ran into this performance issue.


Any ideas/suggestions is much appreciated.


Thanks,

Patricia

___
rules-users mailing list
rules-users@lists.jboss.org
https://lists.jboss.org/mailman/listinfo/rules-users


Re: [rules-users] Drools-Guvnor ­ question about build and deploy packages

2011-04-19 Thread Patricia Bogoevici
Thanks David for your reply.
To clarify: the performance problem is specifically related to the build 
package. This task takes longer as the package has more and more rules. The 
build package process is complex, and performs also rule validation. That's why 
I asked if there is a way to incrementally update the package binary.
The app I am working on, we streamlined the process of creating a new rule, 
including building and deploying a new snapshot package to propagate the 
changes quick. Because the build task takes longer (as the package has more and 
more rules), it is a problem for the end user, as it feels that nothing happens 
for a while when saves a rule.
Once the new snapshot package is created, the KnowledgeAgent propagates the 
updates into the app without problems.
So, coming back to the build package task: what is the best strategy to create 
snapshot packages, so that the build time does not take a long time when there 
are lots of rules in the package? 
One possible solution I see, is to create a snapshot package for each rule 
within a package, using a custom selector. I haven't tried it, but this 
approach will keep the build time short. However, it doesn't seem natural to me 
to have so many snapshot packages...
thanks,Patricia 


--- On Tue, 4/19/11, David Faulkner david.faulk...@amentra.com wrote:

From: David Faulkner david.faulk...@amentra.com
Subject: Re: [rules-users] Drools-Guvnor ­ question about build and deploy 
packages
To: Rules Users List rules-users@lists.jboss.org
Date: Tuesday, April 19, 2011, 11:51 AM


Patricia,
My understanding (which is certainly open to being corrected) is that in 
general there is no way to do an incremental compilation of rules. The entire 
package is analyzed together and significant optimizations are performed to 
combine common items between rules (which is one of the big reasons why the 
engine executes so well!). So, generally, what you are doing is the best 
practice. 
When you say that you are experiencing a performance hit, are you talking about 
a delay in seeing the updates appear in your production application, or 
something else? Generally, the compilation is a one-time step, and even during 
compilation your enterprise application that is actually using the rules should 
continue to perform quite reasonably, since the compilation is going on in a 
separate application. 
David
From:  Patricia Bogoevici patriciabogoev...@yahoo.com
Reply-To:  Rules Users List rules-users@lists.jboss.org
Date:  Tue, 19 Apr 2011 10:45:59 -0500
To:  Rules Users List rules-users@lists.jboss.org
Subject:  [rules-users] Drools-Guvnor – question about build and deploy packages


I am using Drools-Guvnor 5.1 release in
an enterprise application. The rules created are separated per
packages, and for each package there is a snapshot package called
LATEST. The KnowledgeAgent polls the snapshot packages
to get the latest data and load into the rule engine. Whenever there is a new 
rule, or
updates to an existing one, the application triggers the process of
re-creating the package snapshot: builds all the rules within the
package, and creates a new snapshot for the package.
The main problem with this approach is
that the time to build the package rules, increases quite a lot as
the number if rules gets higher. This creates a serious performance
hit in the real-time app whenever there is a change to the rules.
I sneaked a bit to the source code, and
noticed that when build package is called, Guvnor builds a new binary for all 
the rules within a
package even though not all of them are modified. Would it be possible to 
incrementally create/update the package binary? This would speed up
things a lot when the package has lots of rules but only one rule
changes at the time.
What is the best approach for creating
the package snapshots? The approach we've taken is to build all the
rules within a package into one snapshot, and we ran into this performance 
issue. 

Any ideas/suggestions is much
appreciated.
Thanks,Patricia 

-Inline Attachment Follows-

___
rules-users mailing list
rules-users@lists.jboss.org
https://lists.jboss.org/mailman/listinfo/rules-users
___
rules-users mailing list
rules-users@lists.jboss.org
https://lists.jboss.org/mailman/listinfo/rules-users