Work on the synthetic read benchmark

Include no read aggregation data in graph

More SPECsfs runs

Work on a tool for a synthetic read benchmark

Add an option to disable aggregating reads in the proxy

This is for benchmarking purposes.  It uses range requests but does not
delay submitting the reads (to wait for batching opportunities).

Minor changes to graphs and benchmark control scripts

Extract wall clock timestamp of each run when parsing sfsres files

Benchmark results using more concurrent requests and no crypto

SPECsfs results from repeating the Azure measurements

Add an option to disable cryptographic operations

This is intended for benchmarking, to measure the overhead of just the
non-cryptographic operations.

Speed up the deletion of all files in an Azure container

NFS trace replay results

Merge git+ssh://vrable1.sysnet.ucsd.edu/scratch/bluesky

Revert "Enable real-time trace replay instead of maximum-speed replay mode."

This reverts commit c0cab09e97b2c3fce55a743a978e4ea81b5ffbdb.

Check in new benchmark results

Plot updates

Check in new Azure benchmark results

SPECsfs results for the non-log-structured case

Check in some of the recent SPECsfs results

Try to improve support for no-aggregation mode

Make it at least a bit more performance-competitive by fetching objects
when prefetching is requested.

SPEC benchmark setup using no range requests

Also a few graph updates.

Results from a SPECsfs run with 8GB of memory

Optimize overwrites of the last block of a file

Drop another debugging message in non-verbose mode

Really use the US-West region for the SPECsfs benchmark

Update to a warning message to provide more debugging info

Updates to scripts for a mixedbench microbenchmarking run

Check in some old data regarding S3 performance

These experiments ought to be re-run, but use the old data as a placeholder
for now.

Server rename for benchmarks

Tweaks to code that handles read-modify-write on data blocks

Prepare for microbench re-run with latest code

Reduce verbosity

Add a script to parse the S3 and NFS traffic statistics from a run

Updates to automatic SPECsfs-launching script

Reorganize benchmark scripts to support running SPECsfs as well

Some configuration files for possible Postmark benchmark runs

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.