execution: move execution number back to ModelChecker class

clean out includes, etc.

model: embed the trace_analyses in the class

action: add <stdlib>

For exit() and EXIT_*

scanalysis: allocate structures as true members of class (not pointers)

They're all snapshotting, so it makes sense to make them legitimate
members of the SCAnalysis class.

scanalysis: fixup spacing

Merge cleanup branch

This branch separated ModelChecker into two separate classes/modules. It was a
big disruptive change, and it was not compile-able at some points (the BROKEN
commit and some of its successors). Hence the non-fast-forward merge here, to
record the divergent portion of history as special.

schedule: drop the ModelChecker::check_promises_thread_disabled interface

model / threads: remove global get_next_id() interface

promise: get reference to ModelExecution

scanalysis: use ModelExecution interfaces

scanalysis: install ModelExecution object in the analysis

execution: add 'const'

model: cleanup a few more interfaces

These public interfaces are no longer presentin ModelChecker.

model: add get_execution() interface

BROKEN: restructure much of ModelChecker as ModelExecution class

This will *not* compile fully. It is an interim step in which I move
much of the ModelChecker code into a separate class which does not need
to be globally-accessible. The next few commits should fix the compile
problems as I rewrite/remove some interfaces.

datarace: simplify raceCheck{Read,Write}() function interfaces

The user should not have to pass in a ClockVector.

datarace: make globals static

They're only global within this file.

model: drop public get_current_node() interface

model: remove public check_promises() interface

model: add synchronize() function

To prevent code duplication.

common: drop model_print_summary()

This can cause problems if we include it in the output of ASSERT().

promise: add Promise::get_index function

action: we don't need special cases for lock/join anymore

move license to LICENSE file

Merge cleanup code from Brian N.

traceanalysis: rename to remove '_'

bugmessage: move struct to header file

fix weird duplicated code

params: move model_params to header file

model: add too_many_steps()

model: fixup whitespace

scanalysis: fix warning

canalysis.cc: In member function ‘bool SCAnalysis::processRead(ModelAction*, ClockVector*)’:
scanalysis.cc:162:78: warning: suggest parentheses around ‘&&’ within ‘||’ [-Wparentheses]

scanalysis: remove whitespace

clean up printing a little for cycle cases...

more implementation of scanalysis...

implementation of scanalysis and printout code...  should work now

more implementation of scanalysis...
seems like it might work at this point, but need code to tell whether it is a SC trace or not and which parts are SC

towards supporting scanalysis...
added some accessor methods in model.cc for external analyses

add some support for traceanalysis plugins

add some support for traceanalysis plugins

improve documentation + Doxygen formatting

action: refactor, move VALUE_TRY{SUCCESS,FAILED} out of header

cyclegraph: kill unused promise_list_t type

snapshot: cleanup/document much of fork-based snapshotting

We can consolidate much of the fork-based snapshotting "context"
variables so that they are easier to understand; we essentially only
need two types of contexts, the "shared" context used for the client
program (i.e., the model-checker) and the "private" context, which
each snapshot process uses for running and managing its state. That way,
we only have a single process using the "shared" context at a time,
while the others reside in their private context.

Additionally, I add an "exit" context, which is used just to help with
terminating processes once they have to roll back.

Otherwise, this commit contains renaming and documenting of several
fields, variables, etc.

snapshot: use sizeof(*fork_snap)

model: remove DEBUG action print

A ModelAction should only be printed at certain points, where the action
is guaranteed to be consistent (e.g., its reads_from pointer is valid).
Rather than try to position this print opportunely, just drop it; we
already print out the whole trace, which should be sufficient.

snapshot: clean up fork-based error handling

This is an ugly attempt at error handling. Kill the useless variables,
reword the debug prints, and use perror().

action: correct RF capitalization

model: deadlock: print the culprit thread, when known

datarace: use variable-argument bug-printing

model: add variable arguments for bug messages

model: proactively build/prune is_enabled() set

We should proactively check whether threads are enabled, as this allows
the model-checker to more accurately reason about backtracking, fairness
(particularly, assigning thread priorities), and sleep sets.

This commit causes changes in observed executions for many test
programs. Often, this occurs for programs where the main thread
performs a JOIN on a child thread. Previously, we would only discover
that this thread should be disabled once the scheduler attempts to
execute the JOIN ModelAction. For the period of the trace in which this
disabling isn't discovered, we may try to set backtracking points for
the main thread. These executions just turn into infeasible or
sleep-set-redundant executions anyway.

This can also affect the assertion of thread priority when assigning
backtracking points. If a thread is supposedly "enabled" (but in fact is
not), then we may prevent other threads from running because this thread has
priority. But that thread cannot run, so instead we were doing some
funky things with the remaining ("low-priority") threads.

This fix remedies these sorts of issues by precisely computing the set
of threads which are disabled, waiting on other threads/locks.

model: pull thread control logic out of take_step(), check_current...()

Much of the scheduling and main control loop should be handled closer to
the top-level run() method. This is a start toward putting these
decisions at the appropriate level, making things more clear. Of course,
it's not complete.

snapshot: kill useless macro

We're not reusing this macro, so it's better just to use the standard
perror() followed by exit().

context: move Mac swapcontext() to separate compilation unit

We really don't want model_swapcontext() to ever be inlined on Mac OSX,
since this could potentially cause subtle getcontext()-related bugs to
resurface. Just make it a separate compilation unit (*.cc file).

common: improve redirect_output() error handling

Check the return code and errno results of all system/library calls.
Also delete the extraneous 'fd' variable and use the appropriate
STDOUT_FILENO macro instead of fileno(stdout).

common: make model_print() use OS file descriptor, not C library FILE*

A C library FILE does buffering (and possibly other opaque operations)
that can conflict with the model-checker's methods of snapshotting
memory. Particularly, it seems like we could corrupt and drop data that
was written to model_out, if the data was large enough and buffered in
just the right way.

Really, with the presence of dprintf(), there is no reason to print to a
FILE stream; we can just use the file descriptor (either STDOUT_FILENO
or the descriptor received from dup2()).

This fixes bugs seen in verbose mode, with a lot of extra debug
printing. Some of the output was being dropped.

action: include reads-from-promise in HASH calculations

And include the *value*, since the same promise index can yield
different future values.

test: insanesync: pointer types

Atomic pointers should be stored in atomic_intptr_t/atomic_uintptr_t.
This can throw some extra warnings on 32-bit architectures.

model: note the DPOR addendum

To prevent having problems with this in the future.

model: use get_thread() helper

swapcontext() fix for Mac OSX

We provide our own model_swapcontext() for Mac OSX.

threads: remove wait_list

We can glean the "thread waiting" information without recording it
directly in a list for each thread.

model: use get_mutex() and get_thread_operand() helpers

model: kill lock_waiters_map

This information can be gleaned without the need for a hash-table of
lists.

model: merge duplicated code for WAIT and UNLOCK

test: mutextest: add thread yield point

model: get_mutex() for locating the lock map

The mutex can already be located via get_mutex(), so don't try to guess
whether it was store in the value or location fields of the ModelAction.

action: add ModelAction::is_thread_join() helper

mymemory: fix compiling with !USE_MPROTECT_SNAPSHOT

nodestack: move "behaviors" increment all into Node wrapper function

nodestack: regroup some code

To put "threads backtracking" code together

threads: move circular wait check into Threads::is_waiting_on

A Threads::is_waiting_on(Thread *) interface  provides a more generic
interface, which can be useful for tasks other than just circular wait
deadlock detection.

correct comment typo

check in insane test case...

We don't support such behavior.

fix mistake in promises may allow code...  need to be even more aggressive about fv

main: adjust defaults again

-s 6 -S 4

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

main: change default 'future delay' for promise expiration

From 100 to 10, since 100 is kind of absurd, given the current program
length scalability.

model: re-check pending future values whenever a promise is resolved

This is the second part of the previous bugfix; now we must also allow
stashed pending future values to be re-checked in case a promise has
been resolved which now allows sending the value.

model: bugfix - send future values more eagerly

This is a bugfix to a pretty big problem with our future value pruning,
where we would hold future values as 'pending' until all pending
promises were resolved. Unfortunately, this is unsound and must be
rewritten.

Now, we allow sending some future values even in presence of promises,
if the value is being sent to a load that is later than the last time a
Promise was created. We have a pseudo-proof that this should be correct.

model: refactor add_future_value, add documentation

model: add 'const'

model: rename PendingFutureValue 'act' to 'reader'

To make it more clear

model: rework the resolve-promise interface

We don't need to pass around the promise index; just pass the Promise
pointer around.

add test case...

cyclegraph: propagate RMW atomicity edges down the chain

When we add an edge between 'rmwnode' and 'tonode', we are trying to
ensure RMW atomicity. But 'rmwnode' may itself be read by another RMW
(or, in fact, a chain). So we must follow this chain down before
propagating the atomicity edge.

Also, we have the potential to run into the same problem in
addRMWEdge(), except that in that function, we assume that the RMW is
newly-explored and so does not yet have an outgoing RMW edge. This adds
an ASSERT() to check this property.

model: note how we support seq-cst fences

add our names

add copyright message

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

update git repository with license...  GPL v2

test: rmwprog: add MODEL_ASSERT

Might as well improve this 'litmus' test.

fix memory leak

when we reuse nodes in the nodestack, we will recreate yield information and leak the old array...

model: bugfix - missing SC mo_graph edge

We must enforce a rule such as the following, derived from C++ Section
29.3, statement 3 (second subpoint):

if is_store(X) && is_seq_cst(X) && is_store(Y) && is_load(Z) &&
   is_seq_cst(Z) &&
   X --sc-> Z && Y --rf-> Z && X != Y
then
   X --mo-> Y

This has been checked (via manual test-case) to fix a bug which allowed
an inconsistent mo/sc/rf relationship.

model: refactor r_modification_order 'act != curr' and 'act != rf'

We never want to process 'curr' or 'rf' in r_modification_order, so just
factor this out to the beginning of the loop to save on code clutter
(and potential bugs).

mymemory: enforce that user allocations come from user context

mymemory, threads: add allocator specifically for Thread

clas Thread is a special exception, where user-space allocations should
happend from the model-checker context. So provide a special set of
functions to specifically differentiate these allocations.

model: privatize some thread functions

We never need to call ModelChecker::add_thread from outside
ModelChecker.

We really shouldn't try to call 'remove_thread' from the Thread
destructor. It's unnecessary.

litmus: wrc: add macro for memory ordering

For manual inspection of these tests, one might want to change the
memory-ordering for the loads/stores.

Note that this changes the default to use relaxed.