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.
Move the failure mode of externFloat4calls.someFields.chpl to a future and
disable the mode it fails here.

I copied this test to a separate file so that it could be futurized without
losing the accurate results produced under other circumstances.

Throwing --no-remove-copy-calls causes this test to lose information for extern
record fields not named within Chapel, as an autoCopy does not know to copy that
information over.  The new future always throws this flag, to ensure the failure
mode is visible.
Merged chapel-lang/master
Merge pull request #735 from lydia-duncan/silenceBaselineFailure

Move the failure mode of externFloat4calls.someFields.chpl to a future
and disable the mode under which it fails here.

I copied this test to a separate file so that it could be futurized without
losing the accurate results produced under other circumstances.

Throwing --no-remove-copy-calls causes this test to lose information for extern
record fields not named within Chapel, as an autoCopy does not know to copy that
information over. The new future always throws this flag, to ensure the failure
mode is visible.
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.