Add support for standalone parallel iterators

When a forall loop is parsed, it is translated into a call to the leader and
follower iterators, approximately:

for block in iter(leader) {
  for i in iter(follower, block) {
    body;
  }
}

For standalone iterators, we don't want this nested loop.  To accomplish this,i
I added a condition with a chpl__tryToken.  Now unzippered forall loops are
built as:

if chpl__tryToken {
  for i in iter(standalone) {
    body;
  }
} else {
  for block in iter(leader) {
    for i in iter(follower, block) {
      body;
    }
  }
}

This way, if a standalone parallel iterator exists and can be used, it will be
chosen and the leader-follower case will be folded out during resolution.  If
the standalone iterator does not exist, the standalone side will be removed and
the leader-follower branch will be used.  For the most part standalone
parallel iteration is treated the same as the leader case throughout the rest
of the compiler.  One main exception is that forall intents are not yet
implemented on the standalone side.

A simple standalone iterator is defined in the test
standaloneParallelIter.chpl.  It uses a coforall to generate parallelism
and define blocks and iterates over the blocks yielding individual elements.
It also defines a leader and follower iterator to verify the standalone
iterator is chosen over them and that zippered iteration still calls the
leader/followers.  Finally it uses a for loop that results in a serial
iterator getting called.

Tested on the full suite for standard linux64
Merged chapel-lang/master into standaloneParallelIterators

There were a few conflicts that needed to be cleaned up in build.cpp.
Tested with comm-gasnet.
Add annotations for regressions from 12/05, 11/09

Simon's library mode commit seems to have impacted LULESH and binary-trees.
This doesn't quite make sense, but it's definitely the commit.  I will
investigate further into why this changed and if the impact can be reversed.

We also forgot to note when Brad turned off the task table, improving
compilation and the size of the generated code
Merge pull request #1005 from lydia-duncan/annotateDecPerfReg2

Add annotations for performance changes from 12/05, 11/09

Simon's library mode commit seems to have impacted LULESH and binary-trees.
This doesn't quite make sense, but it's definitely the commit. I will
investigate further into why this changed and if the impact can be reversed.

We also forgot to note when Brad turned off the task table, improving
compilation and the size of the generated code
Do a little cleanup and add some comments in standaloneParallelIterator code

Just a little cleaning up.
Undo uniquify dygraph csv names

This ended up causing way more issues than I expected, first with missing
graphs, and now it prevents annotations for single graphs from being applied.
Reverting the change altogether.
Remove extraneous add to inits in function resolution.

This line was the result of a bad "cut" command.  It was part of a previous if
clause that got removed, and somehow that left it in a different if clause than
where it started.  I reviewed the commit that allowed this, I should've caught
it.  The add was harmless, as it would be dead code the second time it was
reached and so skipped, but still.
Rename STREAM .graphs in studies directory

The csv files we generate for dygraphs get their name from the lowecase
basename of the .graph files. We had some duplicate basenames for some stream
tests. This renames the .graph files in the studies directory so we no longer
have a conflict. Previously we would override the .dat files, so the wrong data
was being loaded for some graphs.

An upcoming patch will add a check to make sure we don't run into this again.
Merge pull request #1008 from ronawho/uniquify-dygraph-csv-name

Undo code in gengraphs to make csv files unique

[reviewed by @lydia-duncan]

This was creating a lot more issues than I expected. I'm undoing the change, and changing the names of the .graph files that led to the non-unique csv files. 

The duplicate files were found with an upcoming patch that will make sure we don't run into this again: 323fb989b8ca2711fb15f1c5811d38a9eb8137f5
Respond to reviewer comment

Make buildStandaloneForallStmt static and remove the forward declaration
Merge pull request #1009 from lydia-duncan/removeExtraneousInsert

Remove extraneous add to inits in function resolution.

This line was the result of a bad "cut" command. It was part of a previous if
clause that got removed, and somehow that left it in a different if clause than
where it started. I reviewed the commit that allowed this, I should've caught
it. The add was harmless, as it would be dead code the second time it was
reached and so skipped, but still.
Merge pull request #1006 from daviditen/standaloneParallelIterator

Add support for standalone parallel iterators

When a forall loop is parsed, it is translated into a call to the leader and
follower iterators, approximately:

for block in iter(leader) {
  for i in iter(follower, block) {
    body;
  }
}
For standalone iterators, we don't want this nested loop. To accomplish
this, I added a condition with a chpl__tryToken. Now unzippered forall
loops are built as:

if chpl__tryToken {
  for i in iter(standalone) {
    body;
  }
} else {
  for block in iter(leader) {
    for i in iter(follower, block) {
      body;
    }
  }
}

This way, if a standalone parallel iterator exists and can be used, it will
be chosen and the leader-follower case will be folded out during resolution.
If the standalone iterator does not exist, the standalone side will be
removed and the leader-follower branch will be used. For the most part
standalone parallel iteration is treated the same as the leader case
throughout the rest of the compiler. One main exception is that forall
intents are not yet implemented on the standalone side.

A simple standalone iterator is defined in the test
standaloneParallelIter.chpl. It uses a coforall to generate parallelism
and define blocks and iterates over the blocks yielding individual elements.
It also defines a leader and follower iterator to verify the standalone
iterator is chosen over them and that zippered iteration still calls the
leader/followers. Finally it uses a for loop that results in a serial
iterator getting called.

Tested on the full suite for standard linux64 and linux64+gasnet
Reviewed by Vass
Update checkGraphFiles to look for duplicate .graph files

Updates checkGraphFiles to look for duplicate .graph files with non-unique case
insensitive names. If there are duplicate .graph files this causes issues for
performance graphs. The csv files we generate are named by using the lower case
basename of the graph files so they will override each other if we have
non-unique .graph files.

This updates checkGraphFiles to do this check, and largely rewrites it to use
better python idioms and to use python functions instead of calling out to
things like 'find'

Also updates the warning in start_test and runs the check when we're doing
compiler performance testing as well.
Update default chpl_home based on Thomas' feedback
Merge pull request #1007 from ronawho/update-checkGraphFiles

Update checkGraphFiles to look for duplicate .graph files

[reviewed by @thomasvandoren]

Updates checkGraphFiles to look for duplicate .graph files with non-unique case
insensitive names. If there are duplicate .graph files this causes issues for
performance graphs. The csv files we generate are named by using the lower case
basename of the graph files so they will override each other if we have
non-unique .graph files.

This updates checkGraphFiles to do this check, and largely rewrites it to use
better python idioms and to use python functions instead of calling out to
things like 'find'

Also updates the warning in start_test and runs the check when we're doing
compiler performance testing as well.