Script update

Update some benchmark-running scripts

Add runtime options to disable some of the log-structured optimizations

Add a debug option to dump statistics counters every ten seconds

Data is appended to a file, so that it can be analyzed later.  Timestamps
are incldued to align results with benchmarks.

Parse and reorganize some microbenchmark results

Track inter-request delay in TCP analysis

When analyzing TCP connections, track the time the connection goes idle
(between the end of one request and start of the next).

Disable profiling collection entirely when no data is requested

Note down more kernel compile benchmark results

Tweak inode prefetching

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.