Relacy Race Detector Todo List:

- use indirection and indices for TLS, because on Windows TLS index is DWORD (not DWORD_PTR) (eliminate pointers?)
+ provide rl::hash_ptr()
- support for fair timed waits
+ remove iteration count estimation from full sched -> causes division by 0
- history: memory allocation before object ctor (new T (...))
+ code in test::after() affects iteration count with full scheduler -> final and estimated iteration counts are the same

- non-deterministic sub-expression calculation:
foo(bar.load(std::memory_order_acquire), baz.load(std::memory_order_acquire));

- post issue:
can't simulate some modification orders in presence of data-races-type-2 for atomic vars:
//thread 1
x.store(1, std::memory_order_relaxed);
y.store(1, std::memory_order_relaxed);
//thread 2
while (y.load(std::memory_order_relaxed) == 0
{}
x.store(2, std::memory_order_relaxed);
-> modification order of 'x' will never be "2, 1"


 [CORE]
- initially run threads one by one
- initially run some iterations twice, in order to check that unit-test is deterministic
? add unique identifiers to atomics, vars, mutexes etc (address can be useful too)
- example catalog (description, used techniques, what error is found)
- do I need sched() before atomic loads?
- do I need sched() before mutex unlock?
- for loads output in history value of which store is loaded
- detect dead-code
- output which operations cause data race
? output happens-before matrix, synchronizes-with matrix etc
- SEH handler to catch paging faults
- sched before malloc/free to allow more ABA

 [PERF]
- implement performance simulation
 - cacheline transfers
 - atomic rmw operations
 - fences

[OTHER]
- parallelize the run-time for random scheduler
- parallelize the run-time for tree search scheduler
- manual control over scheduler
- persistent checkpointing of scheduler state (to allow "continue")
- atomic blocks (pdr implementation -> pdr component)
? state space reductions (sleep sets, dynamic persistent sets)
? what can I do with serialization points -> user specifies "visible" results
    system checks for linearizablity -> "visible" results equal to some sequential execution
? save program state inside iteration (save point), continue other iterations from this save point 
? partial order reductions by memorizing happens-before graphs, not program state
? estimate progress by seeing how many iterations it gets to move 0->1 on some stree level
? lower bound, upper bound, mean of progress

O(X) = (P^(C + 3)) * (N^(P + C + 1)) * (P + C)!

