Remove altjit jobs in 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.

1 files changed, 4 insertions, 87 deletions

diff --git a/netci.groovy b/netci.groovy
index 0f6c65096d..f900679702 100755
--- a/netci.groovy
+++ b/netci.groovy
@@ -533,9 +533,7 @@ class Constants {
     // This is the set of architectures
     // Some of these are pseudo-architectures:
     //    armem -- ARM builds/runs using an emulator. Used for Tizen runs.
-    //    x86_arm_altjit -- ARM runs on x86 using the ARM altjit
-    //    x64_arm64_altjit -- ARM64 runs on x64 using the ARM64 altjit
-    def static architectureList = ['arm', 'armem', 'x86_arm_altjit', 'x64_arm64_altjit', 'arm64', 'x64', 'x86']
+    def static architectureList = ['arm', 'armem', 'arm64', 'x64', 'x86']
 
     // This set of architectures that cross build on Windows and run on Windows ARM64 hardware.
     def static armWindowsCrossArchitectureList = ['arm', 'arm64']
@@ -978,11 +976,6 @@ def static setJobTimeout(newJob, isPR, architecture, configuration, scenario, is
         timeout += 60
     }
 
-    if (architecture == 'x86_arm_altjit' || architecture == 'x64_arm64_altjit') {
-        // AltJit runs compile all methods twice.
-        timeout *= 2
-    }
-
     // If we've changed the timeout from the default, set it in the job.
 
     if (timeout != 120) {
@@ -1284,8 +1277,6 @@ def static getJobName(def configuration, def architecture, def os, def scenario,
             baseName = architecture.toLowerCase() + '_cross_' + configuration.toLowerCase() + '_' + os.toLowerCase()
             break
         case 'x86':
-        case 'x86_arm_altjit':
-        case 'x64_arm64_altjit':
             baseName = architecture.toLowerCase() + '_' + configuration.toLowerCase() + '_' + os.toLowerCase()
             break
         default:
@@ -1377,13 +1368,6 @@ def static addNonPRTriggers(def job, def branch, def isPR, def architecture, def
                 case 'armem':
                     addGithubPushTriggerHelper(job)
                     break
-                case 'x86_arm_altjit':
-                case 'x64_arm64_altjit':
-                    // Only do altjit push triggers for Checked; don't waste time on Debug or Release.
-                    if (configuration == 'Checked') {
-                        addGithubPushTriggerHelper(job)
-                    }
-                    break
                 default:
                     println("Unknown architecture: ${architecture}");
                     assert false
@@ -1714,13 +1698,6 @@ def static addTriggers(def job, def branch, def isPR, def architecture, def os,
     }
 
     switch (architecture) {
-        case 'x64_arm64_altjit':
-        case 'x86_arm_altjit':
-            // TODO: for consistency, add "Build and Test" at end.
-            contextString = "${os} ${architecture} ${configuration} ${scenario}"
-            triggerString = "(?i).*test\\W+${os}\\W+${architecture}\\W+${configuration}\\W+${scenario}.*"
-            break
-
         case 'armel':
         case 'arm':
         case 'arm64':
@@ -2027,10 +2004,6 @@ def static addTriggers(def job, def branch, def isPR, def architecture, def os,
             break
 
         // editor brace matching: }
-        case 'x64_arm64_altjit':
-        case 'x86_arm_altjit':
-            // Everything default
-            break
 
         default:
             println("Unknown architecture: ${architecture}");
@@ -2086,16 +2059,8 @@ def static calculateBuildCommands(def newJob, def scenario, def branch, def isPR
             switch (architecture) {
                 case 'x64':
                 case 'x86':
-                case 'x86_arm_altjit':
-                case 'x64_arm64_altjit':
                     def arch = architecture
                     def buildOpts = ''
-                    if (architecture == 'x86_arm_altjit') {
-                        arch = 'x86'
-                    }
-                    else if (architecture == 'x64_arm64_altjit') {
-                        arch = 'x64'
-                    }
 
                     if (scenario == 'formatting') {
                         buildCommands += "python -u tests\\scripts\\format.py -c %WORKSPACE% -o Windows_NT -a ${arch}"
@@ -2109,9 +2074,7 @@ def static calculateBuildCommands(def newJob, def scenario, def branch, def isPR
 
                     // If it is a release build for Windows, ensure PGO is used, else fail the build.
                     if ((lowerConfiguration == 'release') &&
-                        (scenario in Constants.basicScenarios) &&
-                        (architecture != 'x86_arm_altjit') &&
-                        (architecture != 'x64_arm64_altjit')) {
+                        (scenario in Constants.basicScenarios)) {
 
                         buildOpts += ' -enforcepgo'
                     }
@@ -2151,17 +2114,11 @@ def static calculateBuildCommands(def newJob, def scenario, def branch, def isPR
 
                         if (isR2RScenario(scenario)) {
 
-                            // If this is a ReadyToRun scenario, pass 'crossgen' or 'crossgenaltjit'
+                            // If this is a ReadyToRun scenario, pass 'crossgen'
                             // to cause framework assemblies to be crossgen'ed. Pass 'runcrossgentests'
                             // to cause the tests to be crossgen'ed.
 
-                            if ((architecture == 'x86_arm_altjit') || (architecture == 'x64_arm64_altjit')) {
-                                testOpts += ' crossgenaltjit protononjit.dll'
-                            } else {
-                                testOpts += ' crossgen'
-                            }
-
-                            testOpts += ' runcrossgentests'
+                            testOpts += ' crossgen runcrossgentests'
                         }
                         else if (scenario == 'jitdiff') {
                             testOpts += ' jitdisasm crossgen'
@@ -2205,15 +2162,6 @@ def static calculateBuildCommands(def newJob, def scenario, def branch, def isPR
                                 buildCommandsStr += envScriptSetStressModeVariables(os, Constants.r2rStressScenarios[scenario], envScriptPath)
                             }
 
-                            if (architecture == 'x86_arm_altjit') {
-                                buildCommandsStr += envScriptAppendExistingScript(os, "%WORKSPACE%\\tests\\x86_arm_altjit.cmd", envScriptPath)
-                                testOpts += " altjitarch arm"
-                            }
-                            else if (architecture == 'x64_arm64_altjit') {
-                                buildCommandsStr += envScriptAppendExistingScript(os, "%WORKSPACE%\\tests\\x64_arm64_altjit.cmd", envScriptPath)
-                                testOpts += " altjitarch arm64"
-                            }
-
                             envScriptFinalize(os, envScriptPath)
 
                             // Note that buildCommands is an array of individually executed commands; we want all the commands used to 
@@ -2221,14 +2169,6 @@ def static calculateBuildCommands(def newJob, def scenario, def branch, def isPR
                             // into a single script.
                             buildCommands += buildCommandsStr
                         }
-                        else if (architecture == 'x86_arm_altjit') {
-                            envScriptPath = "%WORKSPACE%\\tests\\x86_arm_altjit.cmd"
-                            testOpts += " altjitarch arm"
-                        }
-                        else if (architecture == 'x64_arm64_altjit') {
-                            envScriptPath = "%WORKSPACE%\\tests\\x64_arm64_altjit.cmd"
-                            testOpts += " altjitarch arm64"
-                        }
                         if (envScriptPath != '') {
                             testOpts += " TestEnv ${envScriptPath}"
                         }
@@ -2677,12 +2617,6 @@ def static shouldGenerateJob(def scenario, def isPR, def architecture, def confi
                 return false
             }
             break
-        case 'x86_arm_altjit':
-        case 'x64_arm64_altjit':
-            if (os != 'Windows_NT') {
-                return false
-            }
-            break
         case 'x86':
             if ((os != 'Windows_NT') && (os != 'Ubuntu')) {
                 return false
@@ -2738,8 +2672,6 @@ def static shouldGenerateJob(def scenario, def isPR, def architecture, def confi
 
         switch (architecture) {
             case 'x64':
-            case 'x86_arm_altjit':
-            case 'x64_arm64_altjit':
                 break
 
             case 'x86':
@@ -2918,19 +2850,6 @@ def static shouldGenerateJob(def scenario, def isPR, def architecture, def confi
         }
     }
 
-    // For altjit, don't do any scenarios that don't change compilation. That is, scenarios that only change
-    // runtime behavior, not compile-time behavior, are not interesting.
-    switch (architecture) {
-        case 'x86_arm_altjit':
-        case 'x64_arm64_altjit':
-            if (isGCStressRelatedTesting(scenario)) {
-                return false
-            }
-            break
-        default:
-            break
-    }
-
     // The job was not filtered out, so we should generate it!
     return true
 }
@@ -3681,8 +3600,6 @@ def static shouldGenerateFlowJob(def scenario, def isPR, def architecture, def c
             }
             break
         case 'armem':
-        case 'x86_arm_altjit':
-        case 'x64_arm64_altjit':
             // No flow jobs
             return false
         default: