Disable futures for cygwin

Cygwin testing takes a while and it doesn't seem to be much benefit of running
futures on cygwin.
First try at .good files to make dist-replicated pass.
Reduced the problem size for test_array_slicing3
to avoid timeouts during nightly testing.
Added to .gitignore and CLEANFILES.
Merged chapel-lang/master
Snapshot of this morning's returns
Remove unnecessary ref temp insertion.
Factor changeRetToArgAndClone().

Further factoring of changeRetToArgAndClone() to get the main routine down to less than a
page.  Also, removed insertions of reference temps which are unnecessary due to the
insertReferenceTemps mini-pass that occurs at the end of callDestructors.
Remove another ref temp insertion.
Merge pull request #736 from vasslitvinov/fix-replicated-dist-testing

Fixed failures in dist-replicated nightly testing.

As of today, we have 60 failures in dist-replicated nightly testing.
With these changes, there should be none.
Most of the changes are:

* Created separate .good files for testing with replicated.
  Checked their correctness.

  Given that the replicated distribution is different by nature
  from the others, we chose this instead of trying to make
  the tests behave the same as for other distributions.

* Provided PREDIFFs to dispatch among .good.
  Augmented CLEANFILES and .gitignore.

* Skipif-ed several tests for replicated.

* Modified a test to account for replication.

* Reduced the problem size for a test to avoid timeout.

Details below.


Note: testing, e.g.

  start_test -compopts -sdistType=DistType.replicated ...

will fail if run under comm=none. That's because
.replicated.good are specific to the number of locales.


Aside: a common pattern in a lot of tests results in this:

  var Dom1D = {1..100} dmapped Replicated();
  var AA1d: [Dom1D] real;
  for i in Dom1D do
    ...AA1d[i]...;

  // same for 2d, 3d, etc.

When run e.g. on 4 locales, it is equivalent to this loop:

  for i in 1..100 do
    ...AA1d[i]...;

performed *4 times*. Each time it accesses the same local
replicand of AA1d.

This is not very intuitive and can be used as an argument to change
the behavior of Replicated.


DETAILS

* Added

  distributions/robust/arithmetic/PREDIFF

derived from distributions/robust/arithmetic/performance/multilocale/PREDIFF.

For a given test, it fires only when .default.good exists.
If so, it checks which .good is pertinent - .replicated, .block, ... -
and copies that one - or .default.good if that one does not exist -
into .good.

* a PREDIFF in a subdirectory of distributions/robust/arithmetic
invokes the above prediff. I chose that over a symlink to make
the failure more obvious.


* For each test that exhibits non-standard behavior of Replicated,
I moved .good into .default.good and created .replicated.good.
NB .replicated.good is sensitive to the number of locales.

I also added .good to CLEANFILES and .gitignore.

The behavioral differences are discussed in the thread re
"Cron Dist replicated (linux64.gnu.gasnet.fifo.flat) 60/0/60"
on the internal mailing list in mid-february 2014.
In summary:

 - domains and arrays print out differently
 - parallel and serial iterations go over each index multiple times,
   once for each locale
 - therefore things like reductions and 'for a in A do a=next();'
   behave differently too


* For each of the above tests, .replicated.good came from the current
test behavior. For each, I checked, sometimes thoroughly sometimes not,
whether that behavior is correct. For a couple of tests I wrote a test
that mimicks the behavior using DefaultRectangular.

The following tests are exceptions - no checking for correctness,
except the first part of Random:

  modules/test_module_Random
  modules/test_module_Norm
  performance/multilocale/assignSlice.chpl


* These tests already had .replicated.good. They were failing
because they had a significant reduction in fork counts.
I did not investigate, just updated .replicated.good:

  performance/multilocale/assignSlice
  performance/multilocale/reduceAlias
  performance/multilocale/reduceSlice
  performance/multilocale/assignAlias
  performance/multilocale/alloc


* Added a skipif for replicated for the following tests:

 - output is nondeterministic under Replicated:

  basics/test_zipper_default
  basics/test_zipper_range

 - the expected optimization does not fire under Replicated;
   a todo is to check whether that is OK:

  optimizations/optimizeOnClauses_basic_record
  optimizations/optimizeOnClauses_basic_tuple
  optimizations/optimizeOnClauses_basic

 - MergeSort gets into "zippered iterations have non-equal lengths"
   which seems correct based on how MergeSort si written:

  modules/test_module_Sort

 - This test crashes under Replicated. I skipif-ed it and created
   a separate trimmed-down future (#706) distributions/dm/hplx.chpl:

  kernels/hpl


* Modified this test to account for replication when present:

  stress/test_many_domains


* Reduced the domain sizes to avoid timeout:

  slicing/test_array_slicing3

This test creates lots of array slices, which is slow for privatized
distributions such as Cyclic and Replicated. The new (rather small)
sizes make the test run, under Replicated and on the machine that
tests it nightly, in ~70 seconds.


* While there, clarified instructions on running the robustness suite
in distributions/robust/arithmetic/README.


Reviewed by Tom.
Turn off mallocOutOfMemory for cygwin

Cygwin also fails to define a useful ulimit function, so any attempts to limit
the memory of this test will not work.  Even though the test will still run and
complete with a higher number of iterations, I think we should treat it the way
we treat darwin and skip it.
Merge pull request #737 from lydia-duncan/fixMallocCygwin

Turn off mallocOutOfMemory for cygwin [reviewed by hilde]

Cygwin also fails to define a useful ulimit function, so any attempts to limit
the memory of this test will not work. Even though the test will still run and
complete with a higher number of iterations, I think we should treat it the way
we treat darwin and skip it.  While I was there, I altered the valgrind skipif to
skip the valgrind exec-only case (since that seemed to be the point).
Turn off cygwin testing for TooManyThreads.chpl

Cygwin doesn't allow you to set the number of threads, so this test is not
useful on cygwin.
Merge pull request #738 from lydia-duncan/tooManyThreadsFix

Turn off cygwin testing for TooManyThreads.chpl

Cygwin doesn't allow you to set the number of threads, so this test is not
useful on cygwin.
Send darwin regression mail to normal lists

Previously it was only sent to the all regressions list. The non-deterministic
errors have been cleaned up so it makes sense to send it to all.
Merge pull request #739 from ronawho/darwin-regression-mail

Send darwin regression mail to normal lists

[trivial, not reviewed]

Previously it was only sent to the all regressions list. The non-deterministic
errors have been cleaned up so it makes sense to send it to all.
Merge pull request #701 from ronawho/cygwin-futures

Disable futures for cygwin

Cygwin testing takes a while and it doesn't seem to be much benefit of running
futures on cygwin.

Future feature request from Brad that seems like a good idea: 

"I had a feature request thought for futures -- curious what you think. I think it'd be nice if, in addition to "futures on" and "futures off" there was a middle setting in which futures would be tested if they had a .skipif file. That way, if one had a future that was cygwin-specific, say, they could add a skipif to skip it on everything other than cygwin; yet the test would still be tested on cygwin (without testing all 500 other futures which are presumably independent of cygwin vs. linux64)."
Try bumping qthreads+gasnet timeout for low core count machines again
Merge pull request #740 from ronawho/qthreads-gasnet-timeouts

Try bumping qthreads+gasnet timeout for low core count machines again

[ok'd by @gbtitus]

There are still some timeouts for cyclic and linux32. Not happy with this 
solution, but it's the best we have right now.
Skip the two tests in test/arrays/deitz/parallelism/stream/ for --baseline

These tests are to ensure that our default settings (--fast-follower enabled)
utilize fast followers and create the right number of tasks for parallel work.
Since both are intended and --baseline turns off --fast-followers, it doesn't
make sense to run these tests under --baseline.