Break monolithic C++ emulation file into smaller units.

Preliminary combinational logic partitioning code.
Cleanup, fix flood logic, deal with more node types.

Need to move register (and memory, memory read) into the island that
provides their values.
First "working" version.

Add debugging printlns.
Skip DotBackend subgraoh clustering if we're partitioning into
islands.
Catch missing nodeIslandId's.
Loop over initial node consumers outside flood()
Optionally move delays nodes into their "source" island.
Use Reg instead of Delay - the latter catches Mem nodes and the
following MemRead isn't handled as a root/input - the algorithm has a
problem with directly connected Input/Delay/Root nodes.
Put input, delay, literal, barren and bogus nodes into island 1.
Turn on debugging; turn off moveDelays; put inputs, lits in their own island.
Deal with Bits inputs - don't flood through them.

Added SQueue (simple queue) without maybe_full support.
Support duplicate nodes in multiple islands (required for Bits
support). There is still a problem with module IOs in the Dot backend.
Use a HashSet for IslandNodes.
Correct bug in flood() handling prefixNodes.

prefixNodes should always be added to the island. And they should be
(and now are) marked externally.
Remove "pcpp" backend - use "c" backend with tests for partitioning.
Turn off partition island debugging.
First attempt at partition island support for clock_lo.
First "real" working version (dot and cpp backends).

Add input "plumbing" to each island that consumes it.
Create a dummy "global" island when we aren't partitioning to simplify
the logic. Write out the "top-level" non-island clock code.
Still some confusion over what/when we need to draw nodes when we draw
edges between them.
Just use "Mem" (not MemRead/MemWrite) as an island boundary - the read
needs to be associated with the code doing the reading, and the write
has to be associated with the code doing the writing.
Remove unused maxIsland code.

The maxIsland code breaks the non-partitioned version. Since we don't
use it, remove it.
Fix partitioning support for the Cpp backend, eliminate the quadratic behavior in the initial node classification and update the flood algorithm to deal with register inputs.

Output the island clock_lo/clock_hi code in the order we would output
it for the non-partitioned case.
Since all input nodes are marked, we don't need to check both marked
and input in processLinks(), but we should flood into the inputs of
input nodes (i.e., registers) so all their inputs come from the same
island.
Don't perform the quadratic "0 inputs" test.
Move registers and memories from their unique island to the island
(single) of their inputs.
Track register and memory nodes separately.
Don't maintain "barren" node list.
Preserve backward compatiblity so old tests pass; add support for unoptimized cpp files.

Updated SQueue code so it actually works.
Add support for unoptimized cpp files, merge file groups (unoptimised
versus optimized).
Preserve clock_hi init and def code order.
Ignore RegReset nodes in processLinks() since we now flood through
register inputs.
Delete PartitionedCpp.scala since we use the one, true Cpp backend.
Fix MultiClockDomain handling.

Glue clock_hi def and init together correctly.
Correct array dimensions for clock_lo/_hi and include "init_mapping_table" in the list of unoptimized files.
Improve performance.

Don't generate the monolithic .cpp file if we're generating optimized
.cpp file groups. We run out of memory on large projects.
Optionally show progress when populating ClockDomains.
Since huge hashes/sets don't work well, use an array of island
hashsets indexed by node _id to determine if a node is in a particular
island.
Output ChiselError.info messages to indicate what we're doing.
Clear memory as we're done with it.
Use immutable HashSets for delivered data structures - with the Island
HashSet array indexed by node, this may not provide any benefit.
Specifiy internal types are mutable.
Don't issue warning if islandHop() can't due to non-unique input
islands.
Return immutable data structures.
Make histogram printing optional.
Define procedure to convert an array of Islands into an array of
NodeIdIslands - for prompt node-to-island mapping.
Put clock_hi init code wasin the correct island.

Ignore Literals when checking register inputs so we can move the
register into the correct island.
Remove commented out code in SQueue().
Compatibility issues, multiple clock domains, top-level dot file module crossings (when partitioning), handling non-bits node input chains.

Output the monolithic cpp file (for compatibility testing).
Put shadow registers in the object to enable clock_hi to work with
partitioned island code where the clock init/def sequences are in
separate functions and there's no local variable to save the register
state in. Perhaps we should have clock-domain specific storage for the
registers where we can toggle active values by updating an index.
Fix bug in the multiple clock domain code that re-initialize the
islandClkCode every time we saw a new island, thereby effectively
forgetting all the previous island/clock domain specific code.
Deal with clock initHi and DefHi independently when partitioning - we
have to run all the initHi code before any of the defHi code.
We may end up with some top level nodes in separate islands when
partitioning. Deal with that case in the Dot backend.
When we're looking for a non-bits node from which to flood in
islandsFromNonBitsNode(), we may hit the end of the chain before
finding one. In this case, don't make the last bits node if it has no
consumers, otherwise, we'll emit that entire chain from the islands
and die with a NullPointer exception when we try to find the island
for that node.
Add controls for shadow register placement; refactor file creation code.
Split large files.

Define LineLimitedFunction() class to help deal with large source
files.
Provide separate optimization flag for the file containing the clone()
method.
Add switches --lineLimitFunctions and --minimumLinesPerFile.
In an attempt to speed up c++ compilation by shrinking files
containing method implementations, we've increased the size of the
circuit object which seems to have a significantly adverse effect on
the clone() method. This requires more research.
Move the function prolog and epilog out of dumpVCDInit() and into
clients so it is amenable to line limiting.