model: implement get_next_replay() and advance_backtracking_state()

model: implement, use schedule_next_thread()

Relies on the rest of the model checker to set the next thread; simply returns
the chosen thread.

model: add prototypes to header

I will implement these functions in the next few commits.

model: add iteration routines for class Backtrack

model: include <cstddef>

NULL is not a builtin keyword in recent C++ revisions. I have to include
<cstddef>.

schedule: replace queue with list

I'll need random access to its elements later.

threads: introduce THREAD_ID_T_NONE

Represents a kind of 'NULL' thread, but for integer IDs.

threads: remove leftover class 'prototype'

model: stash each backtrack event in ModelChecker::backtrack_list

model: add class Backtrack

model: create 'action_list_t' typedef

'std::list<class ModelAction *>' is a long name for a repeated type. Replace
it.

model: convert 'action_trace' to pointer

We need to swap out this list with a new one when we reset, and we want to
retain references to this list easily, so make the ModelChecker::action_trace
member into a pointer to a list.

model: add TreeNode debugging information to print_trace()

model: implement get_last_conflict()

This performs a non-optimized check; that is, it uses a simple O(n) linear
search, when it could utilize O(1) lookups instead... but this isn't even the
full memory model yet, so I'm not working for perfection!

model: flesh out set_backtracking()

Relies on stub get_last_conflict() function.

Note: so far, implementing based on seq_cst model, not the full memory model...

model: flesh out check_current_action()

Relies on a stub set_backtracking() function.

model: add accessors for ModelAction variables

(+ add 'node' member, pointing to the state-space tree just before the action)

tree: bugfix - fix backtrack status

tree: don't use 'NULL' for a thread ID

libthreads: only record 'final' even for thrd_join

model: use TreeNode()

Very basic initialization...

tree: fix invalid free

tree: add class TreeNode

Untested, but ported from Nachos project.

rename threads_internal.h -> threads.h

threads/model: move switch_to_master from class Thread to class ModelChecker

rename binary: libthreads -> model

libthreads: split into libthreads and threads

For user-program vs. internal usage

major rewrite - 'struct thread' replaced with internal 'class Thread'

Rewrite code such that most thread data is kept internally, not within the user
program.

Makefile: add debug compilation flag

scheduler: kill 'replaceable' scheduler

I don't actually need a replaceable scheduler; I need a scheduler that can
switch policies at will. Just remove this level of abstraction for now (it can
be added later if needed).

libthreads: print out trace at end of execution

model: add print_trace() function

Prints out the current program trace.

libthreads: perform 'model checking' when moving to next thread

Simply use the hollow 'check_current_action()' interface to perform model
checking in the thread_system_next() call.

Right now, this just adds the previous (a.k.a. 'current') action to our log.

userprog: use both atomic loads and stores

(Meaningless change to 'user' program; just for testing purposes)

model: add check_current_action() function

This interface provides a wrapper for all our model checking operations on the
current action (at least, ideally this should work...I might need to work on
this a bit).

For now, we just record the program trace of all atomic/thread actions.

libthreads: thread_join: return 'int' as status

threads_internal: pass the current 'action' to the internal thread system

I build a ModelAction object to represent the properties of the current action
that are relevant to the model checker. This action should be passed from the
basic action (atomic_load, atomic_store, thread_yield, etc.) into our thread
library and eventually to the model checker.

I don't use these actions yet, but they will be shortly.

model: add class ModelAction

Represents a single action (sometimes called transition) in our program. This
can be a THREAD_* event (creation, join, etc.) or a relevant read/write
operation (e.g., atomic reads/writes). This object and interface is subject to
change a little...

threads_internal: add 'thread_switch_to_master()' internally

In progress: moving more model-checking/thread actions so that they are
performed only by a system thread, not by the user code.

For now, we replace our uses of thread_yield() (which simply switched to the
next user thread) while thread_switch_to_master() (which will later perform
intermediate actions before choosing the next user thread).

Also, we can begin creating internal and external interfaces in
threads_indernal.h and libthreads.h, respectively.

libthreads: make typedef for 'thread_id_t'

Just in case we need to change it later on, let's use it as a named type.

use my{Malloc,Free} in model-checking code

Also, fixes 'leak' where we forgot to free the main_thread.

malloc: override 'new' and 'delete' globally

Not sure if this is correct...

Q: do we also need to overload new[] and delete[]?

malloc: add myMalloc() and myFree()

common: rename "CONFIG" to "COMMON"

schedule: use STL 'queue' instead of 'list'

remove unnecessary #includes

schedule: make 'current' a private member of the scheduler

schedule: use STL list class instead of custom queue

rename other *.c to *.cc

userprog.c remains for now...

schedule: move schedule.c --> schedule.cc

schedule: create 'class Scheduler' with implementation 'class DefaultScheduler'

libthreads: delete allocated object

model: use 'this' uniformly

model: move model.c --> model.cc

model: change 'struct model_checker' to 'class ModelChecker'

Makefile: switch to C++ builds

stricter typing of function pointers for makecontext()

We need to use functions with no arguments (i.e., 'void (*)()') in order to
retain strict type-checking with makecontext(). Of course, we still circumvent
this type checking with casting, but we should straighten this out sometime...

C++: don't use C++ keywords as names (this, new, etc.)

C++: cast result of malloc

terminology - use 'thread id' instead of 'thread index'

libthreads: use model-checker's thread ID assignment

model: add thread ID assignment function

libthreads: separate private functions from user interface

libthreads: perform all scheduling/model-checking from master thread

To keep all user-space actions under control, we should perform all scheduling
and model-checking from the main system thread. This pushes some of the
thread_yield() logic to a system function (as desired).

libthreads: add THREAD_* states

schedule: exit if we run out of linked-list nodes

model: move 'main_thread' to model_checker struct

move 'current thread' details

The low level details regarding the 'current thread' should be encapsulated in
the scheduler (i.e., 'get_current_thread()'). So we move the 'current' variable
to scheduler.c.

libthreads: utilize new model_checker framework

Just a simple drop-in of the current FCFS scheduler (with the ability to
generically switch out schedulers).

model: add global model_checker initialization

schedule: add replaceable scheduler struct

I may need to replace the scheduler in the future, so modularize it.

model: add stub model.[hc] files

userprog: separate test 'program' out to userprog.c

libatomic: add stub atomic lib header/source

Stub implementations, for testing.

(Temporary: need to find a better generic atomic_int, atomic_long, etc.
implementation)

libthreads: use 'void' in argument list

libthreads: export thread_yield()

We export this for now. The function will need to change for long-term exported
use though.

schedule: return next thread pointer directly

It's better to just return a pointer to the 'next' thread, rather than
sending it through the argument list.

schedule: include libthreads.h

Makefile: turn on all warnings

(That's how I caught the previous error...)

libthreads: include schedule.h (previous mistake...)

Makefile: use ${CC} instead of hardcoding gcc

common.h: move common code (non-user) to header

Enable us to include libthreads.h in a "user program".

libthreads: add thread_current() function

Keeps along the lines of C11/C++11.

C11: thrd_t thrd_current(void);
C++11: namespace this_thread

libthreads: remove unused codepath

libthreads: cleanup startup/exit functions

Free the stacks
Push thread exit management into thread_wait_finish() function

modify "user program"

schedule: set thread to NULL when there is no next thread

reformat DEBUG messages

libthreads: export thread_join() in header

libthreads: merge thread_create() and thread_start()

schedule: add scheduler, thread_yield(), etc.

Could use some cleanup still...

libthreads: fixups

libthreads: cleanup main thread initialization

Create a "thread" for the primary context, rather than handling special logic
for a separate "cleanup" ucontext_t.

add "make tags" (using `ctags`)

libthreads: create header file

libthreads: remove superfluous code

The thread.started field is unnecessary for now.

The initial getcontext() call is unecessary as well. swapcontext() is
better for most instances where we are not creating a new thread.

Remove question mark ('?') from last statement.

add .gitignore

initial commit

Basic working copy of "threads," which execute until completion as soon as
they are launched.