Add script to parse cache dump file.

Python script that takes a cache dump file and a list of cache sizes and
prints, for each, the number of accesses that would occur to that cache
size. Requires Python 2.7+.
One one access happens per line, not per byte.

Before, each byte address requested would count as a separate request.
This has been replaced with a count of the number of cache lines
touched. It's possible that all addresses fit entirely inside a single
line, and therefore only count as a single access. However, it's
possible that the request is not aligned, and would then require
multiple cache requests.
Remove -bf-unique-bytes as a prereq for -bf-cache-model.

Recording -bf-unique-bytes is no longer a prereq for the cache model,
although the two can work together.
Increment total accesses with the number of distinct cache lines requested.
Tally unique hits to the cache and sum total hits later.

During execution, only record unique cache hits, associating a hit
with the cache line. At the end of execution, the total number of
hits a cache size N would have is equal to the sum of all unique
hits to caches sized N and smaller.
Count and report only the hits that occur.

On a miss, add a new line with only a single hit. Then only start
counting the number of total hits with zero.
Deduct cold misses from reported total hits.

Cold hits occur whenever a line is requested that has never made it to
the cache, and therefor misses in all levels. Increment a counter
whenever the line is not found in the cache and deduct that value from
each line's total hits.
Report cold misses in cache dump.

Report the number of cold misses in the cache dump so we can calculate
the miss rate for caches that are bigger than the total unique
addresses.
Simplify handling of cold misses.

The cold miss counter is equivalent to the number of unique addresses in
the cache. This in turn is equivalent to the number of lines in the
cache, and therefor doesn't need to be recorded. As well, any time there
is a miss in the cache, don't record it as a hit; this communicates all
cold misses the same way as the counter did.
report split accesses
missing underscore
Assign a cache to each thread.

Each thread gets its own private cache structure. At the end execution,
cache performance for all threads are merged into a single report such
that total hits to cache size N = sum(hits to thread i cache size N) for
all threads i.
Report split accesses.

Output the number of accesses that require accessing more than one
cache line to service the request.
use a map to find our entry
tmp
reuse distance pretty much
utilize residency vector, but naive
add rb tree implementation of fast stack distance calculation
use red-black interval tree for counting stack distances
debug output