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.

Reduce debugging messages in non-verbose mode.

More work on request profiling.

Add locking, thread-ID tracking to profiling.

Track requests that initiate inode fetches.

Start to add request time profiling.

Allow a "profile" object to be created when a request is received, and
track the time at which various events occur when handling the request.

Add a lookup_last method to the multi-store backend.

Updates to the workload generator to perform a parameter sweep.

Implement very basic grouped fetches of objects from the cloud.

Add an item prefetch call, which for now just collects together items that
have been prefetched and when one of them is actually fetched, a range
request is sent that will cover all the objects.  Thus this doesn't improve
the time to fetch the first object (actually it will hurt), it does arrange
to have objects fetched in groups where possible which reduces the total
number of operations and the time to get subsequent objects.

Add a prefetch method.  At the moment it is a no-op.

Move benchmark results elsewhere, out of the repository.

Return failure code when an S3 put operation fails.

Previously, we were indicating success even when that wasn't true, leading
to errors later when we went to read data we hadn't written.  Now, the
caller can retry the put operation if needed.

Drop a verbose debugging message.

Update disk cache usage tracking to handle sparse files.

Bugfix in partial log fetching.

Do not bother mapping the file until the data is available, otherwise the
mapping may be deleted from under us while we are waiting.

Implement fetching of cloud log items via range requests.

This still needs a bit more work for stability, checking for leaks, etc.,
but implements the basic functionality needed to selectively retrieve just
the needed byte ranges out of cloud log segments to download individual log
items.

Convert rangeset implementation from a hashtable to GSequence.

This gives log(N) performance, but allows us to easily tell if a request
falls in the middle of an object and check for overlaps on inserts (though
that part isn't implemented yet).

Implement a rangeset data type and use it to track items in log segments.

The range set can be used to track which byte ranges in a file correspond
to valid objects, and so can be used in the cloud log code to check that
1) objects are actually available if partial log fetching is implemented,
and 2) that objects being fetched have actually been authenticated (if
needed).

This isn't fully working yet.  The range sets should be changed from a hash
table to a sequence, since some lookups in the cloud log code are into the
middle of an object (to skip the header and remap the data), and that needs
to be handled properly.

Add support for byterange requests in the storage layer.

Rename private structures to remove leading underscores.

This is a cosmetic change, but should make debugging and looking up
structure definitions easier.

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

Updates to the workload generator and some results from runs.