[rules-users] Re: Drools solver performance question

[Greg Barton]

Ah, well that's my point of ignorance, then.  I was thinking in stateless mode. :)  And to do what I suggest in a stateful manner would require a "modifyLogical" type functionality in place of the insertLogical.  i.e.

modifyLogical (object) {
  //do this when the condition obtains
} else {
  //do this when the condition no longer obtains
}

Could be an interesting functionality to have, though.  

--- On Mon, 2/16/09, Geoffrey De Smet <ge0ffrey.spam at gmail.com> wrote:

> From: Geoffrey De Smet <ge0ffrey.spam at gmail.com>
> Subject: [rules-users] Re: Drools solver performance question
> To: rules-users at lists.jboss.org
> Date: Monday, February 16, 2009, 10:25 AM
> Unfortunately, when a constraint rule no longer applies, the
> score wouldn't decrement.
> 
> So this would work in a stateless working memory, where the
> entire score is recalculated for every move of every step.
> But drools-solver works in a statefull working memory,
> where only the part of the score that is dirty is
> recalculated (="score delta") for every move of
> every step.
> Now I haven't experimented with the first option yet,
> though I am pretty sure it's exponentially slower.
> If anyone wants to try it out, it would be nice to confirm
> or break my theory :)
> 
> PS: please keep this discussion on the mailing list, so
> others can benefit from it too.
> 
> With kind regards,
> Geoffrey De Smet
> 
> 
> 
> Greg Barton schreef:
> > What I'm talking about isn't like what
> you've got in that commented out code.  Basically, it
> would use the same rules, matching on an accumulator object
> instead of inserting new Constraint objects, and the last
> rule would match the accumulator and set the score.
> > 
> > rule "multipleQueensHorizontal"
> >     when         $a : Accumulator();
> >         $q1 : Queen($id : id, $y : y);
> >         $q2 : Queen(id > $id, y == $y);
> >     then                                      
> $a.increment();
> > end                                                   
>                                                             
>                                                             
>                                                             
>                                           //
> multipleQueensVertical is obsolete because it is always 0   
>                                                             
>                                                             
>                                                             
>                                                             
>                                                            
> rule "multipleQueensAscendingDiagonal"            
>                                                             
>                                                             
>                when         $a : Accumulator();             
>                           $q1 : Queen($id : id, $ascendingD
> : ascendingD);                 $q2 : Queen(id > $id,
> ascendingD == $ascendingD);
> >     then         $a.increment();
> > end                                                   
>                                                             
>                                                             
>        
> > rule "multipleQueensDescendingDiagonal"
> >     when                 $a Accumulator();            
>                    $q1 : Queen($id : id, $descendingD :
> descendingD);
> >         $q2 : Queen(id > $id, descendingD ==
> $descendingD);
> >     then                                              
>             $a.increment();
> > end
> > 
> > rule "hardConstraintsBroken"
> >     salience -10
> >     when
> >         $a : Accumulator();      then
> >         scoreCalculator.setScore(- $a.intValue());
> > end
> > 
> > 
> > --- On Fri, 2/13/09, Geoffrey De Smet
> <ge0ffrey.spam at gmail.com> wrote:
> > 
> >   
> >> From: Geoffrey De Smet
> <ge0ffrey.spam at gmail.com>
> >> Subject: Re: Drools solver performance question
> >> To: Cc: greg_barton at yahoo.com
> >> Date: Friday, February 13, 2009, 8:42 AM
> >> Hi Greg,
> >> 
> >> Yes, I expected that too, but my experiments
> proved me
> >> wrong (for now).
> >> The current implementation of accumulate backwards
> chains I
> >> believe.
> >> Backward chaining doesn't do score delta
> calculation,
> >> so it's very bad for scalability.
> >> 
> >> Try it yourself with the nqueens example.
> >> Uncomment the code in nqueensScoreRules.drl and
> see what
> >> happens if you go from n=8 to n=16 and more.
> >> 
> >> With kind regards,
> >> Geoffrey De Smet
> >> 
> >> 
> >> 
> >> Greg Barton schreef:
> >>     
> >>> I answered a performance question a user had
> about
> >>> drools-solver, but I'm afraid I answered
> with a
> >>>       
> >> touch of
> >>     
> >>> ignorance about the way drools-solver is set
> up.  His
> >>>       
> >> rules
> >>     
> >>> had a new object being inserted into the
> working
> >>>       
> >> memory each
> >>     
> >>> time a constraint rule was matched.  The
> constraint
> >>>       
> >> objects
> >>     
> >>> were then accumulated by a low priority rule
> at the
> >>>       
> >> end. After looking at the drools-solver examples
> it looks
> >> like
> >>     
> >>> they're all that way.  It strikes me that
> having a
> >>> single accumulator object, and not creating
> and
> >>>       
> >> inserting a
> >>     
> >>> new object in each constraint rule, would be
> more
> >>>       
> >> efficient.
> >>     
> >>>  Is it possible to set this up in a solver
> ruleset? Thanks,
> >>> GreG
> >>> 
> >>> 
> >>>       
> >>>       
> > 
> > 
> >       
> >   
> 
> _______________________________________________
> rules-users mailing list
> rules-users at lists.jboss.org
> https://lists.jboss.org/mailman/listinfo/rules-users