Re: Question on type invariants

[Robert Eachus <rieachus@comcast.net>]

On Wednesday, January 25, 2017 at 3:38:53 AM UTC-5, reinkor wrote:
 
> In principle I could mark A and S with a "last-modified-time-flag" so I can update S when I find it necessary. This has similarities to unix "make". Bad idea?

Responding to this point only, there are two decent ways to maintain last modified values for A and S.  One way is to store timestamps. Update_S then compares the values of last_modified for A and S for equality.  If not equal, copy the timestamp from A to S, and do the update work, otherwise exit immediately.  The potential problem here is that the timestamps may not be of sufficient granularity.  The other approach is to use a counter, updated every time A is.  Again comparing for equality can be used to avoid the excess work.  In this case you need to worry about whether your counter is large enough.  My tendency would be just to use a 64-bit integer.  But you may not have atomic updates for 64-bit values, and S and A may be maintained by different tasks.

For this case, there is a neat trick.  Use a smaller integer type for the counter.  When the S counter value is smaller than the A counter value, set both counters to zero, and do the S update.  This can all be done with a protected object, but with careful coding, it can be done with the counters being marked atomic.  Notice that it is possible that an update to A can occur while processing S.  You may need to use protected objects to insure that S_Update sees a consistent view of A.  However, it doesn't really matter whether the update to A is reflected in the new S, you may just have an additional, unneeded update of S now or later.