Added parSafe=false to a test
An initial version of jacobi-unroll.  Need to ask Ian and Cathie
about the fact that it still doesn't pass the correctness test.
Adding jacobi-unroll example to colostate study.
Merge remote-tracking branch 'upstream/master'
Eliminated valgrind timeouts.
Streamlined the handling of 'exectimeout' in sub_test.
Adding a C test demonstrating that our build of GMP leaks memory.
Okay, NOW it links against our GMP library.  Sheesh

Needed to send -L(library path) in on the compopts line and make sure our
environment for compilation included LD_LIBRARY_PATH being expanded to contain
it as well.
Merge pull request #715 from mstrout/master

Michelle's first pull request. An unrolled version of the Jacobi 1D code used for study of diamond tiling.
Eliminated 'comptimeout' variable from sub_test
following Kyle's reviewer feedback.
Merge pull request #766 from vasslitvinov/fix2-exectimeout-in-sub_test

Streamlined the handling of 'exectimeout' in sub_test.

sub_test used 'exectimeout' - which indicates test execution timeout -
where it meant compilation timeout, besided its intended use.

I replaced these inappropriate uses with 'False', because that's
always the value it would have at those points.

Also I eliminated the initialization of 'exectimeout'
that's no longer needed:

-----------
for testname in testsrc:
    exectimeout = False  <-------------------------- not needed
    for compopts in compoptslist:
        for texecopts in execoptslist:
            for count in xrange(numTrials):
                exectimeout = False
                ... if there is a timeout:
                        exectimeout = True
                if not exectimeout:
                    ... run prediffs ...
                    ... report test success or failure ... 
                if perftest:
                    if exectimeout or status != 0:
                        break
-----------

An earlier commit 626504a also introduced the variable 'comptimeout'.
Kyle suggested it was not needed, so I took it out.

Reviewed by Kyle.
Fix qio_file_path_for_fd so it works in cygwin

qio_file_path_for_fd has three paths that are selected via ifdefs, cygwin was
hitting the fall-back case that always returned "unknown" as the file path.

cygwin can actually use the same code as linux for this operation, so I've
added a check for __CYGWIN__ to that `#if`.
Add a future and skipif for the C test, and skip the original for valgrind

Log the failure behavior on the C test and only run it with valgrind enabled.
Also, skip the original test for valgrind until this future has been resolved.
Glarble blarble whitespace blurble glurble
Merge pull request #756 from vasslitvinov/fix-valgrind-timeouts

Eliminated valgrind timeouts in nightly testing.

A few tests have been consistently timing out in our nightly testing.
This change fixes these timeouts by:

* create .valgrind.chpl copies of the original tests

* add .skipif on the original (do not valgrind)
  and on the copy (only do valgrind)

* for the copy, either reduce the problem size or
  (where that is not possible or practical) increase the timeout or 

* overflowInComputeBlock.chpl seemed unimportant to run under valgrind,
  so skipif it without creating a copy

Once our test system allows us to specify separate timeouts or problem
sizes for valgrind (or any other configuration, e.g. baseline), the
.valgrind.chpl copies can be eliminated in favor of such specifications.

One issue I debated is whether to create the .valgrind.chpl copy
of the test using symlinks (see e.g. #755), 'use', or just plain copy.
I haven't been consistent here, in most cases created plain copies
for non-.chpl files and 'use' + call the other main() for .chpl.

The following tests cannot use 'use' because of a known bug
'use' a module whose init has 'begin' outside of any 'sync' crashes compiler,
hence synlinks were needed:
  capture.chpl
  captureAppearsToWork
  stress.chpl

There was no easy way to reduce the problem size for the following tests,
so I increased the timeouts. If they remain problematic, we should revisit:
  io/ferguson/ctests/qio_test.test.c
  release/examples/benchmarks/lulesh/lulesh.chpl
  studies/lammps/shemmy/p-lammps-n1.chpl


TEST DETAILS
  [xx/yy] - time it takes on an idle machine with valgrind / without valgrind

io/ferguson/ctests/qio_test.test.c
  [<26 min/<1 min]
  increased the timeout to 2000

parallel/begin/sungeun/capture.chpl
parallel/begin/sungeun/captureAppearsToWork.chpl
  [5s/?]
  the test starts 250 'begin's at the same time,
    each waiting on a 'single' var
    5s is time under valgrind on an idle machine;
    since we oversubscribe the machine for nightly testing,
    I suppose that it causes the execution time to increase a lot
  reduced the problem size to 10

release/examples/benchmarks/lulesh/lulesh.chpl
  [<12min/7s] for execopt #4
  increased the timeout to 1000

studies/hpcc/PTRANS/PTRANS.chpl
  [>35 min/10s]
  reduced the problem size

studies/lammps/shemmy/p-lammps-n1.chpl
  [>21 min/32s]
  increased the timeout to 2000

studies/lammps/shemmy/p-lammps-n2.chpl
studies/lammps/shemmy/p-lammps-n4.chpl
  these are identical to -n1;
  should no longer be tested under valgrind due to #755

types/range/bradc/overflowInComputeBlock.chpl
  [<35 min/16s]
  skipif for now
  talking to Brad, it will probably go away altogether

types/single/sungeun/stress.chpl
  [1s/?]
  similar to capture.chpl above
  reduced the problem size to 10


Reviewed by Thomas
Numa widens pointers, so the amount of memory "leaked" is larger.

LeakedMemory6 looks at the memory before and after a function that increases
the length of an array.  Therefore "memory leaked" should be one pointer greater
than before the function is run.
Take Vass's comment into account.
Handle another possible failing output in hplx.chpl.
Merge pull request #774 from lydia-duncan/gmpLeakCTest

Gmp leak c test [reviewed by Vass]

Add a future to demonstrate the leak of memory from our GMP build,
as discovered in test/modules/standard/gmp/ferguson/gmp_dist_array.
Turned off that test for valgrind until this issue has been resolved.
Merge pull request #776 from lydia-duncan/numaGoodLeakedMemory

Numa widens pointers, so the amount of memory "leaked" is larger.

LeakedMemory6 looks at the memory before and after a function that increases
the length of an array. Therefore "memory leaked" should be one pointer greater
than before the function is run. On numa, this means 16 instead of 8