[PEAK] Trellis + expensive operations

[Sergey Schetinin]

On Wed, Nov 26, 2008 at 01:29, Christopher Stelma <chris at digsby.com> wrote:
> I'm trying to avoid some unnecessary computation, and I feel I must be
> missing something, either in terms of Trellis API or approach to the
> problem.
>
> I have a value y which depends on x.  x would be a trellis managed piece of
> data.  The computation of y from x is expensive.
>
> Right now, I have a pattern something like:
>
> class A(object):
>     x = None
>     last_x = None
>     last_y = None
>     @property
>     def y(self):
>         if self.x != self.last_x:
>             self.last_y = some_expensive_calculation(self.x)
>         return self.last_y
>
> I would like to accomplish something equivalent with Trellis attributes or
> Cells, so that I don't have to repeat the computation unless the computed
> value would change.  Using a maintenance rule, y would be recomputed every
> time some dependency in x changed.  Using a compute rule, y is recomputed
> every time I access y.  My goal is to be able to set x some number of times,
> followed by accessing y some number of times, but only ever do the
> calculation once.  I realize that this effect may be achieved by an optional
> maintenance rule, but I'd like the same effect for every set of x and every
> access of y, not just the first access of y.

I think this can be accomplished by creating a cell type that when it
runs does not recompute itself  unless there are listeners. If there
are none it just sets some flag that indicates that it will need to
recompute on next access and preserves its dependencies. Its get_value
would check that flag and actually compute the value and cache it, it
would also need to make sure that dependencies are updated at this
point.




-- 
Best Regards,
Sergey Schetinin

http://s3bk.com/ -- S3 Backup
http://word-to-html.com/ -- Word to HTML Converter