Added '--disjunct' option to disable collocate entities on a server into scripts/{cluster.py, clusterperf.py}
Merge branch 'master' of ssh://fiz.stanford.edu/git/ramcloud
Basic secondary indexing now seems to work end-to-end.
(Benchmarking has not yet been done.)

This commit adds more tests:
1. In IndexletManagerTest for some corner cases.
2. In MasterServiceTest to check that it requests insertion/
   removal of correct index entries on object write / remove.
3. End to end test in RamCloudTest that tests writing indexed
   objects, looking up / reding them, removing them, and attempting
   to lookup / read them again.

This commit also fixes some bugs:
1. IndexletManager now includes constructor/destructor for KeyAndHash
   structure used as key in indexlet tree key. This ensures that
   keys sent over rpcs are copied over safely. This code was
   contributed by Ashish Gupta.
2. Waiting mechanism improved for rpcs to Index servers.
3. Other small bug fixes (missing break statements, incorrect for
   loop conditions, amongst others) + adding debug msgs + lint removal.
Write & remove object in ObjectManager now return ref to removed obj.

The writeObject() and removeObject() functions in ObjectManager
now return a pointer to the buffer in log for the object being
overwritten or removed, if any.

This will be used by indexed writes and indexed removes to get data
about (old) index entries to remove.

Note that a similar functionality already existed in removeObject().
This new mechanism is much simpler and (probably) more efficient.
Indexing code now uses new writeObject, removeObject (prev commit).
This makes it cleaner and possibly more efficient.

Also fixing a bug so that an rpc to insert / remove an index entry
gets sent only if that entry is not null.
On remove/write, return to client before sending index remove rpcs.

Also cleaning up related code.
Removing completed/redudant todo messages left over.
Optimizations and improvements in Indexing code.

Main changes include:
1. MasterService invokes index entry insert and remove rpcs (in MasterClient)
   such that it can first initiate all the rpcs then wait to receive them.
   Earlier, MasterService invoked a higher level method in MasterClient that
   sent and received each rpc, which didn’t allow such pipelining.
2. In IndexletManager (on an index server), hold a lock on the entire indexlet
   map only while reading / modifying indexlet mapping information.
   While reading / modifying a specific indexlet, release the indexlet map lock
   and hold an indexlet specific lock.
3. Improve interface between ObjectManager and MasterService for indexedRead()
   operation. The new interface exposes the maximum length of data allowed to
   append to ObjectManager, which helps significantly reduce code complexity.
4. Added ClientException corresponding to STATUS_UNKNOWN_INDEXLET for
   completeness (we don’t expect this exception to be thrown to the client).

Minor changes include:
1. Remove calls to reset buffer that were not needed since the underlying rpc
   mechanism does it anyway.
2. Minor bug fixes.
3. Documentation improvements, lint removal.
Converting btree instance to a pointer to have consistency with the new
(object) btree code. Creating and deleting the btree instance on adding
and removing an indexlet in indexlet manager. Keeping a pointer to objectManager
inside indexletManager for the new (object) btree code. Removing IndexletManager.h
from ObjectManager.h to avoid cyclic dependency.
This patch supports atomic log commit for multiple log entries
from a buffer. This is currently used by the B-tree module to
batch up node modifications to maintain tree consistency
across crashes.

This mechanism can potentially be used by other modules as well.
Transactions is an example.

NOTE: At some point, this may need to be revisited to get cleaner
abstractions which could involve refactoring of ObjectManager
i) Update copyright information from previous commit

ii) Modified IndexletManager::removeEntry() to avoid walking the tree twice
Increased the default master memory size to 40 MB from 32 MB
and fixed corresponding unit tests. This was required because
the B-tree module creates several log entries which push the
limits of the master's memory
More support for new (object) B+ Tree. Creating table at the time of
index creation and making that information available to indexlet
manager. B+ Tree will use the table to map index nodes to objects.

Note: Index tables have name "__indexTable:*:*" and clients should not
to use similar table names.
Merge branch 'master' of ssh://fiz.stanford.edu/git/ramcloud
Merge branch 'master' of ssh://fiz.stanford.edu/git/ramcloud
B+-tree implementation using RamCloud objects.
This guarantees that the tree is persisted and
is recoverable using normal crash recovery. The
patch uses the atomic commit for multiple log
entries mechanism to guarantee consistency and
to avoid garbage on backups.

A subsequent patch will make this the default
B+ tree implementation that the Indexing mechanism
uses.

The code is placed under a new directory under src/
and does not replace the malloc version of B+ tree.
This makes it easier to benchmark both variants
of the B+ tree. As before, by default, this code
is excluded by make check and make tests

NOTE: There are still a few things to address
including possible optimizations and code clean
ups but this can wait until after the deadline
for OSDI '14.
This patch makes the B+ tree implementation using RamCloud
objects the default for Indexing in RamCloud. Since we currently
have the malloc version as well, the only difference in code
for using either of them is a different constructor and a
different namespace for the 'btree' class.

Other small changes in this patch include some unit test fixes
and some changes in lookupIndexKeys() for the new and slightly
different iterator semantics.