Age | Commit message (Collapse) | Author | Files | Lines |
|
* Delete Jenkins scripts
* Delete support files for the old CoreFX test infrastructure
* Delete CoreFX test file setup utility
|
|
* First stab at running the format jobs in AzDO.
* Add display names for formatting jobs.
* Try to use a python version in the path
* Try to fix bootstrap download.
* Use imported paths. Output python major version.
* Clean up imports.
* Fix imports.
* Try just using urlretrieve again
* Cleanup
* Add back killing spurious dotnet processes.
* Try leaving all shutdown/kill work to AzDO.
* PR Feedback.
|
|
|
|
|
|
One problem we've had in coreclr Jenkins when running corefx
tests (in the coreclr outerloop runs -- the ones using the
run-corefx-tests.py harness) is the inability to exclude
failing tests for x86 or x64, and the inability to have
fine-grained exclusions. This has led to problems like
https://github.com/dotnet/coreclr/issues/22442 where
virtually all Windows x86 and x64 corefx runs fail due to
timeouts. And issues like https://github.com/dotnet/coreclr/issues/24159
where all corefx test legs fail, and we have no control
over exclusions to get them all passing again quickly.
Now that the corefx RunTests.cmd/sh wrapper scripts
parse named arguments, including a response file that
is passed on to xunit, and also that the corefx used
xunit has support for this response file as well as
fine-grained exclusions (per-method/per-class/per-namespace),
we can take advantage of it.
This change adds a single, global, corefx xunit exclusion
response file, that will be used for all platforms. Since this
run-corefx-tests.py mechanism is not expected to live much longer,
this seems sufficient.
|
|
Only the corefx jobs are left. The rest should be done in AzDO,
and scheduling both AzDO and Jenkins is causing too much work
for the few machines we have.
|
|
|
|
These are required by the innerloop flow jobs.
|
|
* Remove innerloop flow jobs that were missed
* Correctly exclude windows x64 jobs as well
* Address pr feedback
|
|
It appears our arm64 machines don't have 'zip', so are failing
to archive the final results.
|
|
* Disable Jenkins Innerloop Jobs
This change will:
1) Remove default PR trigger jobs from being run in jenkins
2) Start submitting tests for linux arm32 in coreclr-ci
It is worth noting that this change will not remove jobs from netci.groovy.
This is to say that it is still possible to trigger innerloop and outerloop
jobs in jenkins, they will just not be run automatically on each new PR.
Past this point coreclr-ci will be the only PR triggered jobs to appear in Coreclr.
To see test results, navigate to the coreclr-ci Azure Dev Ops page at:
https://dev.azure.com/dnceng/public/_build?definitionId=228 and view the build related to your PR.
There is a test tab which will report all test results.
* Address PR feedback
* Add queue to array syntax
* Do not create push trigger jobs
|
|
|
|
These were only being archived for successful runs, which is
when they are the least interesting. Archive them for all test runs.
|
|
* Use Microsoft Container Registry for docker images
https://github.com/dotnet/dotnet-buildtools-prereqs-docker has been updated to publish docker images to the Microsoft Container Registry.
* Also update netci.groovy
|
|
|
|
|
|
|
|
* Fix ifdef for `g_DbgSuppressAllocationAsserts`.
It needs to be defined under `FEATURE_INTEROP_DEBUGGING`.
* Unify contracts disabling for UNIX/ARM.
It also disables some parts that were disabled for ARM, but not for UNIX.
It fixes the difference that we see between ARM32 and ARM64 Unix Checked.
* Disable contracts on arm64.
FIxes the difference that we see between windows arm32 and arm64 in checked/debug builds.
* Revert CoreFX arm64 timeout change.
That is no longer necessary.
* Reenable arm64 corefx jobs.
They should not fail with timeouts anymore.
* Don't allow `g_DbgSuppressAllocationAsserts` defnition in release builds.
* delete AssertAllocationAllowed
|
|
This reverts commit d617f96303c4b65b7b77ff5fa0d7aee38ebc19f8.
|
|
Disable Windows arm64 corefx cron jobs
|
|
Configure MSBuild debug path and save any logs
|
|
These currently all fail with timeout. They also take way too much time
to run. We have good Linux/arm64 corefx test coverage already.
The issue of these runs being slow is tracked by
https://github.com/dotnet/coreclr/issues/21236.
|
|
|
|
We have had many problems in the CI with MSBuild failing, and not
capturing the failure logs.
See https://github.com/dotnet/coreclr/issues/20236.
So, for all msbuild invocations, set MSBUILDDEBUGPATH to a new,
distinguished, subdirectory of the bin\Logs directory, named
"MsbuildDebugLogs". Change the CI to upload any log files found
there.
|
|
Even if the build fails. Add archiving in more cases where it was missing.
|
|
This reverts commit 193d5da27fecb7bf95e7342f1c4b9e2b63ce5313.
|
|
* increase arm64 debug/checked timeout.
* Increase timeout only for corefx jobs.
|
|
Move Jenkins off the Ubuntu.1604.Arm64.Open queue so it can be repurposed for Azure DevOps. This "Iron" queue should only be used by Jenkins.
|
|
|
|
And disable Windows_NT and Ubuntu arm32 and arm64 default triggers in Jenkins CI
|
|
|
|
We have full native jobs for arm32 and arm64 for all scenarios, which
is a superset of everything we've run using altjit. So the altjit
jobs are no longer necessary. In addition, the altjit jobs,
especially the corefx jobs, have never run cleanly, for reasons
that have never been investigated or understood. Since we have
full native corefx runs, there is no reason to look into the altjit
failures.
|
|
Two things:
1. Turn "echo" back on after runtests.cmd, so we see in the log file
the testReports.zip compression.
2. Change the archiving of testReports.zip to not occur even if the
test run fails (this is actually the most interesting case), and don't
fail if there is nothing to archive.
|
|
* Collect Windows test run logs into testReports.zip file
And upload these to Jenkins, so we can see how the tests ran.
* Archive test Reports even if the test run fails
* Need to use "call" when invoking runtest.cmd batch file
|
|
arguments for Linux/arm cross build (Part 2) (#21034)
* Stop building and publishing Hostx86/arm crossgen on Linux/arm
* Remove -crosscomponent argument and stop using CAC_ROOTFS_DIR environment variable in build.sh
* Simplify the related logic in build.sh
* Don't need to specify crosscomponent in tests/scripts/run-pmi-diffs.py
* Don't set CAC_ROOTFS_DIR in buildpipeline, Jenkins files and in tests/scripts/run-pmi-diffs.py
* Adjust documentation
|
|
* And also create Linux arm64 crossgen_comparison scenarios in netci.groovy
|
|
* Add -altjitarch command line argument in tests/runtest.cmd and -altjit_arch in tests/runtest.py
* Specify altjitarch in for x86_arm_altjit and x64_arm64_altjit jobs in netci.groovy
* Use AltJitArch MSBuild variable in tests/issues.targets to exclude tests based on either BuildArch or AltJitArch since both two JITs are running in altjit scenarios
|
|
(#20836)
* Don't use crosscomponent|-crosscomponent command line args in build.sh
* Don't use CROSSCOMPONENT environment variable in build.sh src/pal/tools/gen-buildsys-clang.sh
* Remove mentioning -crosscomponent from usage() in build-test.sh
* Don't use -crosscomponent in buildpipeline
* Don't use -crosscomponent in Groovy files
* Remove mentioning crosscomponent in Documentation/building/linux-instructions.md
* Stop building Hostx86/armel crossgen in build.sh
* Disable CrossGen-ing of System.Private.CoreLib on Linux/armel
|
|
|
|
The "bin" directory is now under the "artifacts" directory.
|
|
Fix corefx folder for Tizen job
|
|
https://ci.dot.net/job/dotnet_coreclr/job/master/job/armel_cross_checked_tizen_innerloop_prtest/
|
|
|
|
Also, convert asm from ZIP to tar on non-Windows.
|
|
* Respond to PMI asm diffs code review feedback
Add some try/finally code to improve robustness.
Remove direct invocation of run.cmd.
Also, simplify the generated asm directory hierarchy.
* Improve PMI script error code
Only return non-zero if there is a fatal error. For non-fatal error,
such as the existence of asm diffs, return zero. This will allow
subsequent "build" steps in netci.groovy to run, namely, the
archiving of the asm directory.
Later, determine a better way figure out how to deal with the existence
of asm diffs.
* Update dotnet SDK download links
|
|
|
|
* Use build-test.sh script on Linux (#20333)
* Use *.tgz archive format and tar tool on Unix (#20381)
* Fix paths to "..\Common\common.csproj" in ilproj (#20407)
|
|
A set of CI jobs is defined to generate assembly diffs:
```
Windows_NT x64 Checked pmi_asm_diffs
Windows_NT x86 Checked pmi_asm_diffs
Ubuntu arm Cross Checked pmi_asm_diffs
Ubuntu16.04 arm64 Cross Checked pmi_asm_diffs
Windows_NT x64_arm64_altjit Checked pmi_asm_diffs
Windows_NT x86_arm_altjit Checked pmi_asm_diffs
```
Most of the work is in the run-pmi-diffs.py script. This script:
1. Expects a "diff" build to exist.
2. Clones the baseline branch and builds it.
3. Downloads the dotnet CLI and unpacks it.
4. Clones the jitutils tree and builds it.
5. Generates asm with both the "baseline" and "diff" compilers, currently just on System.Private.CoreLib.dll, but that can be easily expanded (and perhaps we could create new jobs that do different sets of diffs, such as frameworks or benchmarks or all tests)
6. Runs jit-analyze.
The Linux arm/arm64 jobs do cross-compilation, so much zip and copy the build artifacts to a test machine to run.
This has been tested in the dev/unix_test_workflow branch, e.g. #20357
There is still some work to do:
1. Properly figure out the correct baseline commit.
2. Make the Linux arm/arm64 runs work (there are still some problems).
3. Do a better job surfacing the results, e.g., post back to the GitHub PR comments with the jit-analyze results.
4. Enable Linux x64 asm diffs jobs
5. Respond to code review feedback, e.g. (a) make various Python script improvements to handle failure modes, (b) do better temp directory creation, (c) use Tools\dotnetcli and init-tools instead of downloading/unpacking/installing a "live" dotnet CLI, (d) don't invoke run.cmd directly. Maybe use "build-test skipmanaged skipnative" instead?
|
|
|
|
* Use runtest.cmd for arm(64) windows testing
* Correct archival
* Address pr feedback
* Correct containsKey to containsValue
* Change to just use contains
|