GitLab

- Memory and registers are split up into typed atomic cells
- Value type now contains only scalar values
- Instructions are compiled down to WMM "operations", allowing stores
  and loads of composite values to be split up into atomic parts
- Scheduler now executes one operation at a time, rather than one block
  at a time
- New scheduler steps for WMM
- Commands (formerly Thread Actions) such as allocation now executed at
  the global scheduler level. Action IDs no longer needed.
- Threads and stacks changed completely; registers now stored in stack
  frames
- Monads pretty-print properly again!
- Patricia trees replaced with sptrees

Lots of code is still commented out, and tests still don't work, but
the main formalization code compiles.

- Free was changed from a store message to a thread_action message
- Stack frames are now freed properly when returning from a function
- Heap/stack addresses are tracked separately again
- New stores are added to invalidation buffers, per the spec
- Thread actions are executed now
- Tests still don't work yet

It's finally done! The first memory consistency proof in the formalization:
a sequentially consistent schedule (one that always commits memory messages
from the front of a thread's outbox queue) will always produce locally
sequentially consistent semantics.

Changes made in the process of this proof include:

- Removed thread IDs and stack IDs from the thread and stack records;
  keeping up with invariants for them was pointless bookkeeping

- Defined custom tactics multi_case_tac and rw_assums, which greatly
  reduced the size and complexity of some proofs

- Added several new invariants to state_ok, including memory consistency
  invariants (committed messages are all distinct, no message can be in
  both the commit list and a thread's outbox, etc.)

uvmThreadSemantics was becoming a huge file that took several minutes
to compile, so it's been split into uvmThreadsStacks and
uvmInstructionSemantics.

In uvmThreadsStacks, new 'thread_ok' and 'stack_ok' predicates define
basic consistency requirements for thread and stack data structures.
All functions in this file have also been proven to produce valid
thread/stack structures when given valid input. This is a prerequisite
for proving execution state homomorphisms.

'thread_state' has been renamed to 'thread', and 'state_follows' has
been renamed to 'thread_follows'.