Revert "Add the arm64 unix CI"

diff --git a/netci.groovy b/netci.groovy
index 79d5368..9df7e63 100755 (executable)
--- a/netci.groovy
+++ b/netci.groovy
@@ -146,15 +146,11 @@ class Constants {
     def static architectureList = ['arm', 'arm64', 'x64', 'x86']
 }
 
-def static setMachineAffinity(def job, def os, def architecture, def options = null) {
+def static setMachineAffinity(def job, def os, def architecture) {
     if (architecture == 'arm64' && os == 'Windows_NT') {
         Utilities.setMachineAffinity(job, os, 'latest-arm64');
-    } else if (architecture == 'arm64' && os != 'Windows_NT' && options == null) {
-        Utilities.setMachineAffinity(job, os, 'arm64-small-page-size');
-    } else if (architecture == 'arm64' && os != 'Windows_NT' && options['large_pages'] == true) {
-        Utilities.setMachineAffinity(job, os, 'arm64-huge-page-size');
-    } else if (architecture == 'arm64' && os != 'Windows_NT' && options['is_build_only'] == true) {
-        Utilities.setMachineAffinity(job, os, 'arm64-cross-latest');
+    } else if (architecture == 'arm64' && os == 'Ubuntu') {
+        Utilities.setMachineAffinity(job, os, 'arm-cross-latest');
     } else if ((architecture == 'arm') && (os == 'Ubuntu' || os == 'Ubuntu16.04' || os == 'Tizen')) {
         Utilities.setMachineAffinity(job, 'Ubuntu', 'arm-cross-latest');
     } else {
@@ -343,14 +339,8 @@ def static getJobName(def configuration, def architecture, def os, def scenario,
             }
             break
         case 'arm64':
-            if (os.toLowerCase() == "windows_nt") {
-                // These are cross builds
-                baseName = architecture.toLowerCase() + '_cross_' + configuration.toLowerCase() + '_' + os.toLowerCase()
-            }
-            else {
-                // Defaults to a small page size set of machines.
-                baseName = architecture.toLowerCase() + '_' + configuration.toLowerCase() + '_' + "small_page_size"
-            }
+            // These are cross builds
+            baseName = architecture.toLowerCase() + '_cross_' + configuration.toLowerCase() + '_' + os.toLowerCase()
             break
         case 'arm':
             // These are cross builds
@@ -392,7 +382,11 @@ def static addNonPRTriggers(def job, def branch, def isPR, def architecture, def
                     Utilities.addGithubPushTrigger(job)
                     break
                 case 'arm64':
-                    Utilities.addGithubPushTrigger(job)
+                    if (os == 'Windows_NT') {
+                        Utilities.addGithubPushTrigger(job)
+                        // TODO: Add once external email sending is available again
+                        // addEmailPublisher(job, 'dotnetonarm64@microsoft.com')
+                    }
                     break
                 default:
                     println("Unknown architecture: ${architecture}");
@@ -593,9 +587,8 @@ def static addNonPRTriggers(def job, def branch, def isPR, def architecture, def
             if (os != 'CentOS7.1' && !(os in bidailyCrossList)) {
                 assert (os == 'Windows_NT') || (os in Constants.crossList)
                 if (architecture == 'arm64') {
-                    if (os == 'Windows_NT') {
-                        Utilities.addPeriodicTrigger(job, '@daily')
-                    }
+                    assert (os == 'Windows_NT')
+                    Utilities.addPeriodicTrigger(job, '@daily')
                     // TODO: Add once external email sending is available again
                     // addEmailPublisher(job, 'dotnetonarm64@microsoft.com')
                 }
@@ -615,6 +608,7 @@ def static addNonPRTriggers(def job, def branch, def isPR, def architecture, def
             if (os != 'CentOS7.1' && os != 'OSX10.12' && !(os in bidailyCrossList)) {
                 assert (os == 'Windows_NT') || (os in Constants.crossList)
                 if (architecture == 'arm64') {
+                    assert (os == 'Windows_NT')
                     // TODO: Enable a periodic trigger after tests are updated.
                     // Utilities.addPeriodicTrigger(job, '@daily')
                     // TODO: Add once external email sending is available again
@@ -1112,6 +1106,7 @@ def static addTriggers(def job, def branch, def isPR, def architecture, def os,
                 'jashook',
                 'JosephTremoulet',
                 'pgavlin',
+                'pkukol',
                 'russellhadley',
                 'RussKeldorph',
                 'sandreenko',
@@ -1128,49 +1123,6 @@ def static addTriggers(def job, def branch, def isPR, def architecture, def os,
             ]
 
             switch (os) {
-                case 'Ubuntu':
-                case 'Ubuntu16.04':
-                    switch (scenario) {
-                        case 'pri1':
-                            if (configuration == 'Release') {
-                                Utilities.addGithubPRTriggerForBranch(job, branch, "${os} ${architecture} ${configuration} Priority 1 Build and Test", "(?i).*test\\W+${os}\\W+${scenario}.*")
-                            }
-                            break
-                        case 'r2r':
-                            if (configuration == 'Checked' || configuration == 'Release') {
-                                Utilities.addGithubPRTriggerForBranch(job, branch, "${os} ${architecture} ${configuration} R2R pri0 Build & Test", "(?i).*test\\W+${os}\\W+${configuration}\\W+${scenario}.*")
-                            }
-                            break
-                        case 'pri1r2r':
-                            if (configuration == 'Checked' || configuration == 'Release') {
-                                Utilities.addGithubPRTriggerForBranch(job, branch, "${os} ${architecture} ${configuration} R2R pri1 Build & Test", "(?i).*test\\W+${os}\\W+${configuration}\\W+${scenario}.*")
-                            }
-                            break
-                        case 'gcstress15_pri1r2r':
-                            if (configuration == 'Release' || configuration == 'Checked') {
-                                Utilities.addGithubPRTriggerForBranch(job, branch, "${os} ${architecture} ${configuration} GCStress 15 R2R pri1 Build & Test", "(?i).*test\\W+${os}\\W+${configuration}\\W+${scenario}.*")
-                            }
-                            break
-                        case 'r2r_jitstress1':
-                        case 'r2r_jitstress2':
-                        case 'r2r_jitstressregs1':
-                        case 'r2r_jitstressregs2':
-                        case 'r2r_jitstressregs3':
-                        case 'r2r_jitstressregs4':
-                        case 'r2r_jitstressregs8':
-                        case 'r2r_jitstressregs0x10':
-                        case 'r2r_jitstressregs0x80':
-                        case 'r2r_jitstressregs0x1000':
-                        case 'r2r_jitminopts':
-                        case 'r2r_jitforcerelocs':
-                            if (configuration == 'Release' || configuration == 'Checked') {
-                                def displayStr = getR2RStressModeDisplayName(scenario)
-                                Utilities.addGithubPRTriggerForBranch(job, branch, "${os} ${architecture} ${configuration} ${displayStr} R2R Build & Test", "(?i).*test\\W+${os}\\W+${configuration}\\W+${scenario}.*")
-                            }
-                            break
-                        default:
-                            break
-                    }
                 case 'Windows_NT':
                     switch (scenario) {
                         case 'default':
@@ -1531,10 +1483,6 @@ def static calculateBuildCommands(def newJob, def scenario, def branch, def isPR
                         buildCommands += "build.cmd ${lowerConfiguration} ${arch} linuxmscorlib"
                         buildCommands += "build.cmd ${lowerConfiguration} ${arch} freebsdmscorlib"
                         buildCommands += "build.cmd ${lowerConfiguration} ${arch} osxmscorlib"
-                       
-                        if (arch == "x64") {
-                            buildCommands += "build.cmd ${lowerConfiguration} arm64 linuxmscorlib"
-                        }
 
                         // Zip up the tests directory so that we don't use so much space/time copying
                         // 10s of thousands of files around.
@@ -1696,25 +1644,14 @@ def static calculateBuildCommands(def newJob, def scenario, def branch, def isPR
                     }
                     break
                 case 'arm64':
-                    def standaloneGc = ''
-                    if (scenario == 'standalone_gc') {
-                        standaloneGc = 'buildstandalonegc'
-                    }
+                    // We don't run the cross build except on Ubuntu
+                    assert os == 'Ubuntu'
 
-                    if (!enableCorefxTesting) {
-                        buildCommands += "ROOTFS_DIR=/opt/arm64-xenial-rootfs ./build.sh skipmscorlib verbose ${lowerConfiguration} ${architecture} cross clang3.8 skipnuget ${standaloneGc}"
-                        
-                        // HACK -- Arm64 does not have corefx jobs yet.
-                        buildCommands += "git clone https://github.com/dotnet/corefx fx"
-                        buildCommands += "ROOTFS_DIR=/opt/arm64-xenial-rootfs-corefx ./fx/build-native.sh -release -buildArch=arm64 -- verbose cross clang3.8"
-                        buildCommands += "mkdir ./bin/Product/Linux.arm64.${configuration}/corefxNative"
-                        buildCommands += "cp fx/bin/Linux.arm64.Release/native/* ./bin/Product/Linux.arm64.${configuration}/corefxNative"
+                    buildCommands += """echo \"Using rootfs in /opt/aarch64-linux-gnu-root\"
+                        ROOTFS_DIR=/opt/aarch64-linux-gnu-root ./build.sh skipmscorlib arm64 cross verbose ${lowerConfiguration}"""
 
-                        // Set time out
-                        setTestJobTimeOut(newJob, scenario)
-                        // Basic archiving of the build
-                        Utilities.addArchival(newJob, "bin/Product/**,bin/obj/*/tests/**/*.dylib,bin/obj/*/tests/**/*.so", "bin/Product/**/.nuget/**")
-                    }
+                    // Basic archiving of the build, no pal tests
+                    Utilities.addArchival(newJob, "bin/Product/**", "bin/Product/**/.nuget/**")
                     break
                 case 'arm':
                     // Cross builds for ARM runs on Ubuntu, Ubuntu16.04 and Tizen currently
@@ -1807,12 +1744,8 @@ combinedScenarios.each { scenario ->
                     // Skip totally unimplemented (in CI) configurations.
                     switch (architecture) {
                         case 'arm64':
-                            if (os == 'Ubuntu16.04') {
-                                os = 'Ubuntu'
-                            }
-
-                            // Windows and Ubuntu only
-                            if ((os != 'Windows_NT' && os != 'Ubuntu') || isBuildOnly) {
+                            // Windows only
+                            if (os != 'Windows_NT' || isBuildOnly) {
                                 return
                             }
                             break
@@ -2042,8 +1975,7 @@ combinedScenarios.each { scenario ->
                     // Create the new job
                     def newJob = job(Utilities.getFullJobName(project, jobName, isPR, folderName)) {}
 
-                    def machineAffinityOptions = architecture == 'arm64' ? ['is_build_only': true] : null
-                    setMachineAffinity(newJob, os, architecture, machineAffinityOptions)
+                    setMachineAffinity(newJob, os, architecture)
 
                     // Add all the standard options
                     Utilities.standardJobSetup(newJob, project, isPR, "*/${branch}")
@@ -2127,23 +2059,11 @@ combinedScenarios.each { scenario ->
 combinedScenarios.each { scenario ->
     [true, false].each { isPR ->
         // Architectures.  x64 only at this point
-        ['x64', 'arm64'].each { architecture ->
+        ['x64'].each { architecture ->
             // Put the OS's supported for coreclr cross testing here
             Constants.crossList.each { os ->
-                if (architecture == 'arm64') {
-                    if (os != "Ubuntu") {
-                        return
-                    }
-                }
-
                 Constants.configurationList.each { configuration ->
 
-                    if (architecture == 'arm64') {
-                        if (scenario != 'default' && scenario != 'pri1r2r' && scenario != 'gcstress0x3' && scenario != 'gcstress0xc') {
-                            return
-                        }
-                    }
-
                     if (Constants.jitStressModeScenarios.containsKey(scenario)) {
                         if (configuration != 'Checked') {
                             return
@@ -2289,18 +2209,13 @@ combinedScenarios.each { scenario ->
                         testBuildScenario = 'default'
                     }
                     def inputWindowTestsBuildName = ''
-                    def inputWindowsTestBuildArch = architecture
-                    if (architecture == "arm64") {
-                        // Use the x64 test build for arm64 unix
-                        inputWindowsTestBuildArch = "x64"
-                    }
                     if (Constants.jitStressModeScenarios.containsKey(testBuildScenario)) {
                         inputWindowTestsBuildName = projectFolder + '/' +
-                            Utilities.getFullJobName(project, getJobName(configuration, inputWindowsTestBuildArch, 'windows_nt', 'default', true), isPR)
+                            Utilities.getFullJobName(project, getJobName(configuration, architecture, 'windows_nt', 'default', true), isPR)
                     }
                     else {
                         inputWindowTestsBuildName = projectFolder + '/' +
-                            Utilities.getFullJobName(project, getJobName(configuration, inputWindowsTestBuildArch, 'windows_nt', testBuildScenario, true), isPR)
+                            Utilities.getFullJobName(project, getJobName(configuration, architecture, 'windows_nt', testBuildScenario, true), isPR)
                     }
                     // Enable Server GC for Ubuntu PR builds
                     def serverGCString = ''
@@ -2542,13 +2457,6 @@ combinedScenarios.each { scenario ->
                                 // Unpack the corefx binaries
                                 shell("tar -xf ./bin/build.tar.gz -C ./bin/CoreFxBinDir")
 
-                                // HACK -- Arm64 does not have corefx jobs yet.
-                                // Clone corefx and build the native packages overwriting the x64 packages.
-                                if (architecture == 'arm64') {
-                                    shell("cp ./bin/Product/Linux.arm64.${configuration}/corefxNative/* ./bin/CoreFxBinDir")
-                                    shell("chmod +x ./bin/Product/Linux.arm64.${configuration}/corerun")
-                                }
-
                                 // Unzip the tests first.  Exit with 0
                                 shell("unzip -q -o ./bin/tests/tests.zip -d ./bin/tests/Windows_NT.${architecture}.${configuration} || exit 0")
 
@@ -2611,11 +2519,6 @@ combinedScenarios.each { scenario ->
                     Utilities.standardJobSetup(newJob, project, isPR, "*/${branch}")
                     // Set timeouts to 240.
                     setTestJobTimeOut(newJob, scenario)
-
-                    if (architecture == 'arm64') {
-                        Utilities.setJobTimeout(newJob, 480)
-                    }
-
                     Utilities.addXUnitDotNETResults(newJob, '**/coreclrtests.xml')
 
                     // Create a build flow to join together the build and tests required to run this

diff --git a/tests/runtest.sh b/tests/runtest.sh
index 886c5b4..ac3e382 100755 (executable)
--- a/tests/runtest.sh
+++ b/tests/runtest.sh
@@ -478,10 +478,6 @@ function load_unsupported_tests {
 function load_failing_tests {
     # Load the list of tests that fail on this platform. These tests are disabled (skipped) temporarily, pending investigation.
     failingTests=($(read_array "$(dirname "$0")/testsFailingOutsideWindows.txt"))
-   
-    if [ "$ARCH" == "arm64" ]; then
-        failingTests+=($(read_array "$(dirname "$0")/testsFailingOnArm64.txt"))
-    fi
 }
 
 function load_playlist_tests {

diff --git a/tests/src/CLRTest.Execute.Bash.targets b/tests/src/CLRTest.Execute.Bash.targets
index 713a42b..a572741 100644 (file)
--- a/tests/src/CLRTest.Execute.Bash.targets
+++ b/tests/src/CLRTest.Execute.Bash.targets
@@ -255,20 +255,8 @@ fi
 ExePath=$(InputAssemblyName)
 $(BashLinkerTestLaunchCmds)
 $(BashCLRTestLaunchCmds)
-if [[ "$_DebuggerFullPath" != "" ]]
-then
-    echo $_DebuggerFullPath $(_CLRTestRunFile) $ExePath $CLRTestExecutionArguments 
-    $_DebuggerFullPath $(_CLRTestRunFile) $ExePath $CLRTestExecutionArguments
-else
-    if [[ "$OSTYPE" == "linux-gnu" ]]
-    then
-        echo timeout 10m $(_CLRTestRunFile) $ExePath $CLRTestExecutionArguments 
-        timeout 10m $(_CLRTestRunFile) $ExePath $CLRTestExecutionArguments
-    else
-        echo $(_CLRTestRunFile) $ExePath $CLRTestExecutionArguments 
-        $(_CLRTestRunFile) $ExePath $CLRTestExecutionArguments
-    fi
-fi
+echo $_DebuggerFullPath $(_CLRTestRunFile) $ExePath $CLRTestExecutionArguments 
+$_DebuggerFullPath $(_CLRTestRunFile) $ExePath $CLRTestExecutionArguments 
 CLRTestExitCode=$?
 $(BashLinkerTestCleanupCmds)
       ]]></BashCLRTestLaunchCmds>

diff --git a/tests/testsFailingOnArm64.txt b/tests/testsFailingOnArm64.txt
deleted file mode 100644 (file)
index c124cb6..0000000
--- a/tests/testsFailingOnArm64.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-JIT/jit64/opt/cse/hugeexpr1/hugeexpr1.sh
-JIT/jit64/opt/cse/HugeArray/HugeArray.sh
-JIT/jit64/opt/cse/HugeArray1/HugeArray1.sh
-JIT/jit64/opt/cse/HugeField1/HugeField1.sh
-JIT/jit64/opt/cse/HugeField2/HugeField2.sh
-CoreMangLib/cti/system/string/StringFormat1/StringFormat1.sh
-CoreMangLib/cti/system/string/StringFormat2/StringFormat2.sh
-JIT/Methodical/tailcall_v4/hijacking/hijacking.sh