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.

Remove debugging messages when decrypting cloud log segments.

Fix Amazon S3 store_lookup_last implementation.

Amazon will return directory listings in chunks.  Be sure to repeat list
calls until we find the actual end of the directory listing.

Fix a memory leak resulting from the in-memory inode map.

Actually release the reference to the old version of an inode when creating
a new one.

Add a more aggressive mode of cleaning up disk space.

If enough space cannot be deleted in the disk cache, drop nearly all clean
data from memory so that most disk cache files are unreferenced, then make
another pass to delete log/cache files.

Move disk cache cleanup code to cache.c from log.c

A few more minor fixes cleaning up the cloud log state counting.

Fix up cloud log state counting.

Counts of cloud log items in various states were not being kept up to date,
so that the counts were often wrong.  Fix a few cases to make the counts
more accurate.

Ignore lockmem executable.

The signature on log items should not extend to the pointer locations.

This allows the cleaner to rewrite the pointers without invalidating the
signature.

Add timeout on cleaner S3 retry.

Add retries to the S3 backend in the cleaner.

Small utility to use free memory in a system.

For benchmarking, to take memory away from the page cache.

Support encrypted log items in the cleaner.

Delete dead code.

When decrypting a log item also clear out the IV field.

Not really needed, but this way the IV field being zero should be
synonymous with an unencrypted log item.

Add per-item encryption/authentication to the cloud log storage.

We should generate encrypted data and decrypt it again on read, but we
don't yet enforce only reading data which passes the integrity check.

Allow S3 bucket used for BlueSky storage to be specified.

Work on a simple workload generator for benchmarking.

Start adding in selective encryption of cloud log items.

Not fully hooked in, but some of the logic for encryption is written now.

Another logging fix.

Fix for journal committing.

Sometimes we could previously, under load, report that journal items were
committed when they were not.  Try to track the uncommitted state more
carefully now.

Implement handling of unstable data in WRITE/COMMIT nfs procedures.

Before all NFS operations were synchronous; now we support asynchronous
commits of file writes which might improve performance.

Updated microbenchmarking script.

Starting work on scripts to automate benchmarking.

Improve cleaner performance.

When reading an object in, seek to and read just the needed bytes instead
of the entire log segment.  Improves performance significantly.

Remove obsolete file.

Use a thread pool for inode fetches, and remove some debugging output.

Remove an extraneous mutex unlock.

I'm surprised that this didn't cause trouble earlier; it seems that
unlocking an unlocked mutex raises no errors (but under heavy load, when
the mutex is locked by another thread then unlocking it can cause trouble).

More fixes for memory management.

This should allow memory and cache space to be reclaimed by not keeping
items pinned in memory, finally.  Still needs a bit more testing.

Work on reducing memory pinned by the inode map.

Add cleaner option to rewrite and compact all inodes (but not all data).

Allow cloudlog items to be unreferenced in the background.

This is to avoid certain deadlocks, when we don't care if resources are
reclaimed immediately or not.

Do not hold references to all inode data in inode map.

The inode map should not hold full refereces to all inode objects and all
corresponding data, since that will lock all such data in memory or the
disk cache.  Do some initial work towards just holding weak references to
the data so that it can be expired from the cache.

Restart journal sequence numbering properly.

Handle the case even where some old journal files have been deleted.

Add in header fields for per-object encryption/authentication.

These aren't yet used.

Add very basic caching to the cleaner S3 backend.

Add S3 backend for the cleaner.

It does not yet cache files so performance is poor.

Properly set the starting inode number for allocation after restarting.

Fix for S3 list operation.

Implement a list operation for the S3 storage backend.

Drop encryption from the cloud storage backend.

Encryption should properly be provided at another layer, so in preparation
for that remove it from the storage layer.

Allow cleaner to delete unused log segments.

It will not delete segments cleaned out in the current pass, just those
that were unreferenced at the start of the cleaning process.

Improve segment cleaning.

Improve cleaner: make sure new logs are written after existing ones.

Extend cleaner with a simple policy for choosing segments to clean.

Updates to the Python cleaner prototype.

This can now read in the old inode maps, rewrite inode data, and write out
an updated inode map/checkpoint.