Rework inode prefetching.

Attempt to coalesce range requests for inodes where possible.

Start keeping notes on tarball unpack, checksum, kernel compile, etc.

Postmark results summary

Minor benchmark additions/changes

Infrastructure to generate PDF figures for the paper

Commit SPECsfs results for an NFS server running in EC2

Re-run some results with newer BlueSky code

Optimize complete overwrites of file system blocks

Do not fetch the old data in this case, since it doesn't matter what it
was.

Check in some more benchmark results for BlueSky/S3-west

Update a results README file

Script for parsing sfsres files to extract more detailed latency values

Benchmark results without range requests.

Reduce verbosity of debugging of disk cache contents

Use virtual hosts for specifying S3 buckets

This is needed to get requests directed to the right place when using
different locations (US-West vs. US-California, for example).

Add more benchmark results

More memory usage stats

Measure effect of read latencies vs. connection idleness

Add more memory overhead data

Update memory usage plot script

Memory usage stats from another benchmark run (on the real proxy)

Statistics on memory usage during a test benchmark run

Include S3-US-West results in graphs

Limit the number of concurrent log uploads to the cloud

This is mostly aimed at limiting memory usage, since each cloud log segment
is stored entirely in memory before it is uploaded, so a very large number
of parallel uploads could require allocating a large amount of memory.

Move encryption of cloud log segments into background threads.

Crypto operations looked to be a CPU bottleneck, but using separate threads
will at least allow multiple log segments to be encrypted in parallel on
separate CPU cores.

Updates to run microbenchmarks against S3 us-west.

Merge git+ssh://c09-44.sysnet.ucsd.edu/scratch/bluesky

Check in results using S3 US-west location.

Merge git+ssh://idril.vpn.vrable.net/home/mvrable/local/bluesky

Print out Azure objects as they are deleted.

Config file for SPECsfs CIFS testing.

Results from SPECsfs runs against Windows Azure.

Plots for the CIFS SPECsfs results.

Merge git+ssh://c09-45.sysnet.ucsd.edu/scratch/bluesky

Make the azure test python script clean up files from BlueSky runs.

Merge git+ssh://c09-44.sysnet.ucsd.edu/scratch/bluesky

Check in some SPECsfs runs for CIFS.

Turn on profiling in microbenchmarking.

Check in README and sample plots for some of the new data.

Checking in some results with a smaller, slower disk.

Parameters for investigating latency anomalies, and results.

Check in some detailed timing results to investigate strange latency vs.
requested load figures.

Merge branch 'master' of git+ssh://niniel.sysnet.ucsd.edu/home/mvrable/local/bluesky

Add some proxy statistics.

Switch disk used for storing data during benchmarks.

Check in some recent SPECsfs benchmark results.

Make NFS rsize/wsize configurable in the microbenchmark runs.

Fix byte range request syntax.

Delete dead code.

Add a CURL connection pool to the Azure backend.

This will allow HTTP connections to be re-used.

Add byte range support to the Azure backend.

Add Windows Azure support to BlueSky.

This is not much tested but seems to work at a basic level.

Check in some minor changes to microbenchmark runs.

Build a quick storage library for accessing Windows Azure.

This will be used by the Python cleaner, but that is not yet hooked up.

Run both read, write, and mixed workloads.

Set up for benchmark runs with small reads/writes within larger files.

More reworking of microbenchmark handling of reads/writes and file layout.

Change how mixed read/write workloads are done in mixedbench

Split reads and writes into separate threads, instead of mixing operations
within a single thread.  This does not allow arbitrary mixes any longer,
since the ratios are quantized based on the number of total threads.

Commit script to parse microbenchmark results.

Delete old benchmark execution script.  It is obsolete.

Update benchmark script to run a few other cases.

Add a "native" target to run the kernel NFS server.

Fix standard deviation estimation.

Properly reset statistics counters between intervals.

More benchmark changes.

Benchmark fixups.

Spread test files for mixedbench across multiple subdirectories.

Reduce effective memory size on benchmark client.

Lock memory to reduce the amount available for the NFS file cache, so
that requests will go the proxy.

Split benchmark file system setup and execution into separate steps.

Allow interval at which benchmark results are printed to be controlled.

Work on automatically running benchmarks.

Minor fix to benchmark running script.

Add script to clean up files from a benchmarking run with nfsproxy.

Add script to delete state from S3 for benchmarking cleanup.

Add script for stopping a running nfsproxy

Add script to run a simple microbenchmark.

Add setup script for starting the proxy for benchmarking.

A few more updates to the mixed read/write microbenchmark.

Changes to output formattng of mixedbench.

Add a new more general-purpose microbenchmark tool in C.

Fix a potential race between creating and destroying mmaped strings

Potentially, we might try to create a new reference to a memory-mapped
region while another thread unreferences and frees that region.  Ensure
when freeing the mapping that there really are no mappings (doube-check
after taking the lock).

Fix a memory leak.

Fix use-after-free in network address lookups.

Update simplestore to use a standard port number.

Add simplestore server to build.

Add a connection pool to the simplesever client

Re-use TCP connections across requests instead of closing the connection
each time.

Start work on a new cleaner backend

Begin adding support for the simplestore backend to the cleaner code.  This
is not yet tested and so probably needs a bit more work.

Rename filestore -> simplestore

This is more consistent with the naming in the rest of the BlueSky code.

Enable range requests in the simple storage backend

Fix off-by-one error in the BlueSky simple storage backend.

One extra byte of data was being included into the data returned, leading
to data corruption.  Fix this.

Check in a new very simple client/server storage protocol implementation.

This is meant for local testing; the server writes data to a local disk
without synchronization so data isn't guaranteed to be durable but this
should provide better performance for benchmarking (where we care about the
BlueSky performance and not the storage sever itself).

Commit a basic but functional online cleaner implementation.

The cleaner needn't be aware of parallelism; the proxy will handle merging
of data.

Fixes and debugging assertions.

Fix a race condition in bluesky_mmap_unref.

It turned out that the old code had a race--between decrementing and
testing the reference count and acquiring the lock, another thread could
potentially acquire a reference, release the reference, and then unmap the
data.  This still left the reference count as zero, so a second unmap was
attempted.  Now, use mmap->addr to detect if the unmap needs to be done or
not which should eliminate this race.

Mostly implement inode merging for the in-proxy cleaner component.

This doesn't yet ensure modifications are serialized out again later.

Fix to the cleaner when writing out a new inode map.

Add code in the proxy cleaner component to iterate over new inodes.

For the moment we actually iterate over all inodes in the cleaned
checkpoint, but later can restrict to just those that are needed.  Actually
merging inode changes also still needs to be implemented.

In-progress commit of online cleaner.

This adds some code to check the cleaner log when the proxy is launched,
but doesn't yet merge any data.

Rework the checkpoint record format to include a version vector.

This will be used for keeping track of whether we have incorporated changes
made by the cleaner or not, and is a first step (along with having the
clenaer write to the a separate set of logs) to making a functional online
cleaner.

Try to avoid accessing profiling objects after they are freed.

Write profile data if and only if requested.

Allow profile results to be written to a file.