Re: How to get Ada to ?cross the chasm??

[Paul Rubin <no.email@nospam.invalid>]

Niklas Holsti <niklas.holsti@tidorum.invalid> writes:
> The Ada programs for satellites on which I am currently working often
> meet with such problems, and either work slower (mutual exclusion
> between readers and writers), use more memory (dual physical copies of
> the data structure) and/or pass the problem to the satellite operators
> (commands to mutate the on-board data structure are delayed or failed
> if the data structure is in use by some reader). Better solutions are
> needed.

I think the natural Ada-flavored solution is use more memory.  You're
describing a classic transactional database update which has
traditionally been implemented using shadow pages.  Basically you write
the record in two places, then commit the transaction by flipping a
pointer.

A low-tech approach if you have MMU hardware is copy-on-write.  That is
how Redis (redis.io) does disk snapshots: when you ask for one, the
process forks, so the child process shares its memory pages with the
parent.  The child process then writes its memory to disk.  If the
parent updates a page while this is happening, the MMU traps the update
and makes a new copy of the page in the parent space.

Using a functional data structure like a red-black tree is also natural,
and this is how Happstack-State (a Haskell database) works.  But I think
its performance isn't that great.

You should definitely check out the book "Purely Functional Data
Structures" by Chris Okasaki if you haven't seen it already.

Because I can't resist, here's a beautiful Haskell implementation of
red-black trees using zippers, with the RB-tree invariants guaranteed by
the type signature:

  https://gist.github.com/2660297 (based on https://redd.it/ti5il)

With newer GHC's you can put the type-level natural numbers directly
into the signature, making it even prettier.