action: add get_mutex()

mutex: fix indentation

action: add get_return_value()

This return value is useful for both printing (debugging) and the
model-checker process_read() function.

model: use get_write_value()

Same implementation for now, but it could change.

model: bugfix - adding a Promise reader can cause failure

model: hack dumpGraph() bug by "leaking" promises

It is possible to end up in an inconsistent state, where a "resolved"
promise may still be referenced if CycleGraph::resolvePromise() failed,
so don't delete 'promise'. Technically, this leaks memory within an
execution, but because it is allocated on the snapshotting heap, this
leak goes away after an execution ends. So, rather than spending more
work on "fixing" the inconsistency, just don't delete the promise yet.

This inconsistency only matters when dumping the mo_graph to file, since
it traverses all the ModelAction/Promise edges, including those that are
semi-dangling mid-merge.

cyclegraph: simplify resolvePromise / mergeNodes

We only ever will merge a single Promise node with a single ModelAction
node. Any other nodes will just create cycles or unresolveable promises.
So we can simplify much of the logic and avoid passing around a vector
of Promises.

model: refactor process_read logic

check_recency: update/add documentation comments

check_recency: improve templates, use when reading from Promise

This completes (?) the improvements to check_recency, such that it now
can force new writes to be "seen" if we are reading from an "old"
Promise too many times in a row.

mpmc-queue-noinit now runs to completion (with ASSERT() enabled):

  $ time ./run.sh mpmc-queue/mpmc-queue-noinit -f 10 -m 2
  + mpmc-queue/mpmc-queue-noinit -f 10 -m 2
  ******* Model-checking complete: *******
  Number of complete, bug-free executions: 119828
  Number of redundant executions: 38743
  Number of buggy executions: 0
  Number of infeasible executions: 344469
  Total executions: 503040
  Total nodes created: 7585797

  real 2m29.674s
  user 2m18.269s
  sys 0m10.929s

check_recency: refactor some more, + include Promises

check_recency *should* now prevent reading from the same Promise too
many times. Not quite getting the test results I want yet, though.

check_recency: return a boolean status

The output of check_recency is actually a boolean (failure => "too many
reads"), so make that explicit.

Also, rework a little more logic to make the structure a little more
obvious.

check_recency: only allow newer stores to "overwrite"

For a "live" memory system, we only want to force a store to appear if
it is modification-ordered after the store we're reading from.

Also, delete my old comment about reads-from feasibility.

check_recency: implement loops as function ModelAction::may_read_from()

This strange loop makes more sense with a name, associated with the
ModelAction class.

nodestack: add support functions for check_recency() w/ Promises

model: check_recency: convert a few things to ASSERT()

At least for now, just to make sure my reasoning is correct.

comments

model: check_recency: fix indentation, spelling, comments

action: bugfix - reads-from value should be VALUE_NONE for new actions

If a new read action hasn't had a chance to choose a valid reads-from or
reads-from-promise, it can have "no" value. This only occurs if we are
terminating an infeasible execution, where there were no valid reads to
read from.

This bug was triggering faults only for verbose printing, were we would
print the status of an incomplete read.

model: fixes for future value passing

For one, we don't want to 'add_future_value()' when w_modification_order
is called anywhere besides process_write(). Also, we want to filter out
potential future values based on the existence of a Promise that this
write must resolve. So pass a vector parameter to w_modification_order
for recording future values only when (and where) we want them.

model: we only resolve one promise at a time

model: fix ASSERT()

Apparently this ASSERT() is still not good. ASSERT() was triggered, for
example, with:

  $ ./run.sh test/linuxrwlocks.o -f 4 -m 1

promise: add 'same_value' helper, force value-checking in CycleGraph

This fixes a potential bug, in which a write could merge with a
different promised value. It's unclear whether this ever manifested
itself, since I believe we had some implicit logic that would ensure
that this did not happen.

promise: bugfix - don't check value, check location

I changed a line previously and didn't even notice that I wasn't
matching the comment anymore! Of course, the comment was correct, and my
code was wrong.

action: add get_write_value()

action: add ModelAction::get_reads_from_value()

We can always get our 'read' value from reads_from or
reads_from_promise, so make it accessible via a function.

action, model: add ASSERT(), not NULL checks

These should never be called with NULL. Don't make them a real
conditional.

cyclegraph/model: unify, clean up graph printing

This fixes several things:

1) The rf edges now are directed properly
2) Read-from-promises show up in the graph
3) ModelChecker uses the same code as CycleGraph for printing a
   CycleNode or graph edge
4) Graphs are more readable; I put a large weight on the
   sequenced-before edges, causing graphviz to try to make these edges
   "shorter, straighter and more vertical" [1]
5) Use the 'SnapshotAlloc' STL allocator for CycleGraph::nodeList

[1] http://www.graphviz.org/doc/info/attrs.html#d:weight

nodestack: get_read_from_promise() never returns NULL

If the read_from_promise_idx is out of bounds, this is an error. We
should not return NULL (and in fact, our caller never expects us to
return NULL).

model/schedule: comput "reduadant" measurement, print along with traces

This will help debuggability. For instance, it will be more obvious that
right now, the 'deadlock.c' test is completing executions as "redundant"
when in fact they should be deadlocks.

cyclegraph: clean up mo_graph dump

Promises should show up with their promise number (or promise "index").
We can also make the edge printing into a generic function.

action: print promise number, not just ?

nodestack: bugfix - clear backtracking properly

promise: record multiple readers in the same Promise

This requires more adjustments throughout ModelChecker.

un-'const' some Promises

I need to modify this Promise sometimes, so don't make it const
everywhere.

nodestack: rewrite promise-resolution "counting"

We don't need to perform a full check of all possible combinations of
Promises to resolve; we only perform 0 or 1 resolution.

model: hook up 'read-from-promise' backtracking in ModelChecker

Now we iterate over the read-from-promise set. Some things are still
missing.

nodestack: add read_from_promises backtracking

This is just the basic framework for now. I still need to hook it up for
actual use in ModelChecker.

nodestack: bugfix - rewrite 'may-read-from' and 'future values' as the same set

There were some subtle bugs that appeared because of the difficulty in
iterating over two separate sets that represent the "read from" set for
a particular read. Now, we expose an interface where there's just a
single pair of functions 'increment_read_from()' and
'read_from_empty()', for iterating over this set, along with a
flag-check 'get_read_from_status()', so that we know where to grab
values from (get_read_from_past() or get_future_value()).

This also does a lot of code moving and documentation in nodestack.cc,
for better readability and organization.

model: shorten some code

model: rename 'reads_from' to 'rf'

nodestack: rename 'read_from' to 'read_from_past'

One step of re-architecting the reads-from set in NodeStack (i.e.,
read from past + promised future values + future values).

model: don't call process_read() for 2nd half of RMW/RMWC

We don't need to call process_read() for the second half of an RMW or
RMWC ModelAction. Anyway, it does next-to-nothing when
'second_part_of_rmw' is true.

model: bugfix - correct the "equality" check for RR coherence

I made a typo when adding this RR coherence edge.

cyclegraph: bugfix - allow to compile with SUPPORT_MOD_ORDER_DUMP

I missed an include that is only used for the mod-order dump support
code.

model: bugfix - correct RR coherence for Promises

We should not skip a read just because it has an unresolved promises;
the CycleGraph can now support read-read coherence edges between any
combination of Promise and ModelAction.

cyclegraph: change Promise nodes map

Map from Promises to Nodes, not ModelAction (readers) to Nodes. This
will make it cleaner when more than one reader maps to the same promise
Node.

model: promises: eliminate threads when they "join"

A thread that joins with another thread can no longer satisfy a promise
from that thread.

schedule: remove commented-out code

model: bugfix - only allow promise satisfaction for "compatible" threads

I overlooked updating the 'compute_promises()' function when modifying
promises such that they are only resolved by a limited set of threads.
This allows compute_promises() to properly prune out those promises
which are not satisfiable by the current thread.

At the same time, move the act->is_read() check to be an ASSERT(), since
we should never see a promise generated by a non-read ModelAction.

threads: construct Thread only with a given "parent"

The Thread constructor really doesn't need to call thread_current(),
since it will always be called from model-checker context. Clean up the
use of default "parent_thrd" parameter and just pass NULL when we have
no parent.

repush changes

fix conflicts
Merge branch 'master' of ssh://demsky.eecs.uci.edu/home/git/model-checker

Conflicts:
schedule.cc

fix norris mentioned bug

Revert "fix scheduling stuff to get nice round robin scheduler behavior..."

This reverts commit 30999f20b8426081e676adfc76d1c4af7b941e8e.

This commit triggers assertions and therefore cannot be used:

$ ./run.sh test/rmwprog.o
+ test/rmwprog.o
Error: assertion failed in model.cc at line 2424
stack trace:
  ./libmodel.so : ModelChecker::resolve_promises(ModelAction*)+0x3bd
  ./libmodel.so : ModelChecker::process_write(ModelAction*)+0x21
  ./libmodel.so : ModelChecker::check_current_action(ModelAction*)+0x42b
  ./libmodel.so : ModelChecker::take_step(ModelAction*)+0x39
  ./libmodel.so : ModelChecker::run()+0xa5
  ./libmodel.so : ()+0x1a3a3
  ./libmodel.so : ()+0x1e786
  ./libmodel.so : main()+0x3c
  /lib/x86_64-linux-gnu/libc.so.6 : __libc_start_main()+0xed
  test/rmwprog.o() [0x400789]
Execution 11: INFEASIBLE: [unresolved promise]
---------------------------------------------------------------------
(   0) Thread: 0    Action: uninitialized   MO: relaxed  Loc:       0x601078   Value: 0                           CV: ( 0,  0)
(   1) Thread: 1    Action: thread start    MO: seq_cst  Loc: 0x7f6cd2016898   Value: 0xdeadbeef                  CV: ( 0,  1)
(   2) Thread: 1    Action: init atomic     MO: relaxed  Loc:       0x601078   Value: 0                           CV: ( 0,  2)
(   3) Thread: 1    Action: thread create   MO: seq_cst  Loc: 0x7f6cd1410590   Value: 0x7f6cd1410560              CV: ( 0,  3)
(   4) Thread: 2    Action: thread start    MO: seq_cst  Loc: 0x7f6cd2016e08   Value: 0xdeadbeef                  CV: ( 0,  3,  4)
(   5) Thread: 2    Action: atomic rmw      MO: relaxed  Loc:       0x601078   Value: 0x1                 Rf: 9   CV: ( 0,  3,  5)
(   6) Thread: 1    Action: thread create   MO: seq_cst  Loc: 0x7f6cd14105a0   Value: 0x7f6cd1410560              CV: ( 0,  6,  0)
(   7) Thread: 3    Action: thread start    MO: seq_cst  Loc: 0x7f6cd2017338   Value: 0xdeadbeef                  CV: ( 0,  6,  0,  7)
(   8) Thread: 2    Action: atomic rmw      MO: relaxed  Loc:       0x601078   Value: 0x2                 Rf: 5   CV: ( 0,  3,  8,  0)
(   9) Thread: 3    Action: atomic rmw      MO: relaxed  Loc:       0x601078   Value: 0                   Rf: 2   CV: ( 0,  6,  0,  9)
HASH 1973598524
---------------------------------------------------------------------

Add breakpoint to line 50 in file common.cc.

fix scheduling stuff to get nice round robin scheduler behavior...

nodestack: bugfix - reset backtracking points on diverging paths

Any time we diverge to a new execution path, we should reset the
backtracking information (i.e., which threads have executed and which
still must be backtracked) for the last node in the stack. We cannot
retain the "explored children" state after we have performed different
read-from or future-value divergence in the same node.

model: bugfix - inherit future values from previous loads

Once a future value is observed once, it should be available for
observation by other loads. Previously, we assume that a future value
will be passed to each load that may observe it. However, as
exemplified in the double-read-fv.c test, this may not be possible when
there are no other feasible stores from which to read.

Thus, when building an initial 'may-read-from' set, we should build a
set of inherited future values as well.

nodestack: don't use C++ references

Just pass-by-value, since the reference can obfuscate the lifetime of,
for example, an automatic variable.

model: correct the "no valid reads" assertion

There are "no valid reads" only if there are no valid prior reads-from
candidates AND no potential values.

promise: stash the whole future_value

We may need to generate a new Promise from the same future_value, so
stash the whole struct and expose it via get_fv().

test: fences: add simple, semi-useful fence tests

Note that due to the quirks discovered in double-read-fv, we don't see
all the expected behaviors in the fences2 test.

test: add double-read-fv

This test fails (!) because we never see r1 = r2 = 42.

action: backtrack/sleep-sets for seq-cst fences

We now backtrack (and wake up sleep-set actions) on all pairs of seq-cst
operations such that at least one of the operations is a write or fence.

model: wake up pending (sleep-set) actions for fences

This completes fence backtracking properly by waking up actions when the
appropriate fence interactions occur. This is a little more complicated
than the simple "could_synchronize()" test, since fence synchronization
can involve interaction of more than two actions.

So, pull the complexity of the "should we wake a thread up" computation
into its own function.

model: only backtrack fences when acquire is before release

Because there are up to 4 actions involved in this search for a
"conflict" (load, fence-acquire, fence-release, store), I overlooked the
fact that we only need to backtrack when the release comes after acquire
in the execution order. This fix skips past the 'release' action before
we begin searching for the 'acquire'.

model: document get_last{,_fence}_conflict()

model: schedule appropriate fence backtracking points

This patch calculates the most recent backtracking point which may be a
fence. We require a separate function for computing this because a fence
"conflict" is much different than other conflicts; fences do not have a
memory location, but instead, they trigger release/acquire backtracking
in the presence of other stores/loads.

Left out of this patch:
(1) Sleep-set waking: even if we backtrack, we don't yet wake up our
    thread properly, yielding a "redundant" trace instead of a
    productive one
(2) memory_order_seq_cst: I have yet to determine how (if at all) we
    need to add additional backtracking in the presence of seq_cst
    fences
(3) documentation: need to describe get_last_fence_conflict() better

model: convert while-loops to for-loops

Make the loop-termination condition more clear.

model: add 'const'

include: fixup header inclusion

don't include action.h from model.h

model/action: move action_list_t to model.h

action_list_t is only used by the ModelChecker class

promise: move constructor out of header

scheduler: refactor round-robin loop

This is the same computation, represented more clearly as a for loop
which, if it reaches the completion condition, means that it did not
find an enabled thread.

model: end-of-execution print

For readability of a "verbose" execution log (and even for the shorter,
non-verbose log), it helps to visually separate the final statistics
from any previously-printed statistics. For instance, in the following
verbose snippet from the end of an execution history, it's confusing why
there are two identical copies of the statistics:

... <other execution history> ...
Number of complete, bug-free executions: 4
Number of redundant executions: 0
Number of buggy executions: 0
Number of infeasible executions: 5
Total executions: 9
Total nodes created: 48

Execution 9:
---------------------------------------------------------------------
... <snipped trace info> ...
---------------------------------------------------------------------

Number of complete, bug-free executions: 4
Number of redundant executions: 0
Number of buggy executions: 0
Number of infeasible executions: 5
Total executions: 9
Total nodes created: 48

model: improve get_next_thread() comments

It's curious that get_next_thread() needs the current ModelAction as a
parameter. It helps to clarify that this argument is somwhat "optional."

schedule: simplify Scheduler::select_next_thread()

Now that the "select next thread" vs. "set_current_thread" is clear, we
don't actually need to set the value of 'current' in
select_next_thread().

model: pull scheduler's thread selection into get_next_thread()

The code makes more logical sense if ModelChecker::get_next_thread()
handles all of the thread selection decisions.

schedule: split Scheduler::next_thread() into separate functions

next_thread() is basically overloaded to perform two different
functions, depending on the parameters. In one case, a caller might pass
a NULL thread, which meant that Scheduler is free to select its own next
thread. In another case, a caller will pass a non-NULL thread, which
meant that the caller is simply informing the Scheduler of the next
thread to execute (i.e., which one is "currently running").

These separate functionalities are now separate functions:

  Scheduler::select_next_thread()
  Scheduler::set_current_thread(Thread *)

model: factor out a 'switch_from_master()' function

This snippet of code is important and somewhat subtle. Although we only
use it once, let's make it a function to give it a higher-level
abstraction.

model: rework the release sequence fixups

It makes more sense to pull the release sequence fixups out of the main
execution loop and only perform them after all other actions are
complete.

There's still some more cleanup to be done here, but it appears that
end-of-execution release sequence fixups are functional again.

model: simple refactoring

This condition is useless. We can just return next_thrd directly.

model/threads: add documentation comments

Document {get,set}_pending(), has_asserted()/set_assert(), etc.

model: fix leaking "pending actions"

ModelActions that are "pending" for each thread are not automatically
freed when we rollback; we keep most of the active ModelActions on the
NodeStack, then we free them from there when we explore a new branch of
the state space.

This fix causes all the pending actions to be freed on any rollback.
This is safe for now, since we always roll back to the beginning of the
execution. If we roll back to an intermediate point, though, we need to
retain those pending actions which were also pending before the rollback
point. Hence the FIXME notice included in reset_to_initial_state().

model: add 'pending' assertion

We don't want to clobber a pending action.

model: stash all pending actions immediately

model: pull 'has_asserted()' check out of take_step()

Checks for mid-execution assertions should occur before take_step().
This can catch a mid-step bug (e.g., data race or user-assertion) that
happens between ModelAction steps.

threads: bugfix - do not call thread_current() from model-checker

thread_current() was designed for use in the user context. It is not
guaranteed to provide a reliable result in the model-checker context,
since we may perform context switches as needed, such that the "last
executed user thread" may not be the thread that we are checking at the
time.

This change is made to clear up future changes that will modify the
scheduling patterns.

model: stash actions in each thread

We don't want a global 'current_action' for saving the next action to
run; we want to stash the 'current action' for each thread. So just use
the 'pending' action in each Thread.

Note that this kinda breaks sleep sets for now. We'll have to redo this.

model: return next thread from take_step()

Note that this intentionally breaks release sequence fixups for now.

threads/model: allocate Thread from w/in ModelChecker

It adds scheduling difficulties if we allocate/schedule a Thread from
the user-context (i.e., directly from the thrd_create() interface)
because then it is not necessarily atomic. For example, if we run a
thread up to its context switch for a THREAD_CREATE then switch to
another thread before the THREAD_CREATE is processed, then we will
already have constructed a Thread from the first thread (and prepared it
for scheduling) without processing it in the ModelChecker appropriately.
For instance, the following schedule might appear, causing problems:

 TID    ACTION
 ---    ------
    ...
  1     ATOMIC_READ         <--- Next action is THREAD_CREATE
 (1)    (construct Thread 3)
 (1)    (prepare new Thread for Scheduling)
  2     ATOMIC_READ
  3     THREAD_START        <--- Before its CREATE event??
  1     THREAD_CREATE

Note that this scheduling does not yet happen, as we always execute
the "lead-in" to THREAD_CREATE atomically. This may change, though.

schedule: assert that model-checker thread doesn't enter scheduler

model: set thread state during 'swap' calls

Rather than setting thread-state from subtle places within ModelChecker,
it makes more logical sense to set it from withing the Thread::swap
functions.

Merge branch 'fences'

promise: use id_to_int()

model: prune may-read-from set early

It helps to prune the may-read-from set (according to modification order
constraints) as we build it. This prevents unnecessary backtracking and
provides a significant (linear) speedup in model-checking speed.

Note that this now allows us to assume that at any point in an
execution, any selection from the may-read-from set is feasible.

action: bugfix - initialize member

model: rewrite mo_check_promises

Rather than use some special logic that was devised when we didn't
include promises in the mo-graph, we can simplify our mo_check_promises
code by querying the mo-graph for reachability. This *should* be at
least as good of a 'check' as the previous code, and much less cryptic.

model: remove argument from mo_check_promises