Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 1 | // Copyright 2020 The Chromium Authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | package gen_tasks_logic |
| 6 | |
| 7 | import ( |
| 8 | "fmt" |
| 9 | "log" |
| 10 | "sort" |
| 11 | "strconv" |
| 12 | "strings" |
| 13 | |
| 14 | "github.com/golang/glog" |
| 15 | "go.skia.org/infra/task_scheduler/go/specs" |
| 16 | ) |
| 17 | |
| 18 | // keyParams generates the key used by DM for Gold results. |
| 19 | func keyParams(parts map[string]string) []string { |
| 20 | // Don't bother to include role, which is always Test. |
| 21 | blacklist := []string{"role", "test_filter"} |
| 22 | keys := make([]string, 0, len(parts)) |
| 23 | for key := range parts { |
| 24 | found := false |
| 25 | for _, b := range blacklist { |
| 26 | if key == b { |
| 27 | found = true |
| 28 | break |
| 29 | } |
| 30 | } |
| 31 | if !found { |
| 32 | keys = append(keys, key) |
| 33 | } |
| 34 | } |
| 35 | sort.Strings(keys) |
| 36 | rv := make([]string, 0, 2*len(keys)) |
| 37 | for _, key := range keys { |
| 38 | rv = append(rv, key, parts[key]) |
| 39 | } |
| 40 | return rv |
| 41 | } |
| 42 | |
| 43 | // dmFlags generates flags to DM based on the given task properties. |
Eric Boren | 457c1eb | 2020-03-16 13:49:33 -0400 | [diff] [blame] | 44 | func (b *taskBuilder) dmFlags(internalHardwareLabel string) { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 45 | properties := map[string]string{ |
| 46 | "gitHash": specs.PLACEHOLDER_REVISION, |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 47 | "builder": b.Name, |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 48 | "buildbucket_build_id": specs.PLACEHOLDER_BUILDBUCKET_BUILD_ID, |
| 49 | "task_id": specs.PLACEHOLDER_TASK_ID, |
| 50 | "issue": specs.PLACEHOLDER_ISSUE, |
| 51 | "patchset": specs.PLACEHOLDER_PATCHSET, |
| 52 | "patch_storage": specs.PLACEHOLDER_PATCH_STORAGE, |
| 53 | "swarming_bot_id": "${SWARMING_BOT_ID}", |
| 54 | "swarming_task_id": "${SWARMING_TASK_ID}", |
| 55 | } |
| 56 | |
| 57 | args := []string{ |
| 58 | "dm", |
| 59 | "--nameByHash", |
| 60 | } |
| 61 | |
| 62 | configs := []string{} |
| 63 | blacklisted := []string{} |
| 64 | |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 65 | hasConfig := func(cfg string) bool { |
| 66 | for _, c := range configs { |
| 67 | if c == cfg { |
| 68 | return true |
| 69 | } |
| 70 | } |
| 71 | return false |
| 72 | } |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 73 | filter := func(slice []string, elems ...string) []string { |
| 74 | m := make(map[string]bool, len(elems)) |
| 75 | for _, e := range elems { |
| 76 | m[e] = true |
| 77 | } |
| 78 | rv := make([]string, 0, len(slice)) |
| 79 | for _, e := range slice { |
| 80 | if m[e] { |
| 81 | rv = append(rv, e) |
| 82 | } |
| 83 | } |
| 84 | return rv |
| 85 | } |
| 86 | remove := func(slice []string, elem string) []string { |
| 87 | rv := make([]string, 0, len(slice)) |
| 88 | for _, e := range slice { |
| 89 | if e != elem { |
| 90 | rv = append(rv, e) |
| 91 | } |
| 92 | } |
| 93 | return rv |
| 94 | } |
| 95 | removeContains := func(slice []string, elem string) []string { |
| 96 | rv := make([]string, 0, len(slice)) |
| 97 | for _, e := range slice { |
| 98 | if !strings.Contains(e, elem) { |
| 99 | rv = append(rv, e) |
| 100 | } |
| 101 | } |
| 102 | return rv |
| 103 | } |
| 104 | prefix := func(slice []string, pfx string) []string { |
| 105 | rv := make([]string, 0, len(slice)) |
| 106 | for _, e := range slice { |
| 107 | rv = append(rv, pfx+e) |
| 108 | } |
| 109 | return rv |
| 110 | } |
| 111 | |
| 112 | blacklist := func(quad ...string) { |
| 113 | if len(quad) == 1 { |
| 114 | quad = strings.Fields(quad[0]) |
| 115 | } |
| 116 | if len(quad) != 4 { |
| 117 | log.Fatalf("Invalid value for blacklist: %+v", quad) |
| 118 | } |
| 119 | config := quad[0] |
| 120 | src := quad[1] |
| 121 | options := quad[2] |
| 122 | name := quad[3] |
| 123 | if config == "_" || |
| 124 | hasConfig(config) || |
| 125 | (config[0] == '~' && hasConfig(config[1:])) { |
| 126 | blacklisted = append(blacklisted, config, src, options, name) |
| 127 | } |
| 128 | } |
| 129 | |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 130 | // Keys. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 131 | keys := keyParams(b.parts) |
| 132 | if b.extraConfig("Lottie") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 133 | keys = append(keys, "renderer", "skottie") |
| 134 | } |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 135 | if b.matchExtraConfig("DDL") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 136 | // 'DDL' style means "--skpViewportSize 2048 --pr ~small" |
| 137 | keys = append(keys, "style", "DDL") |
| 138 | } else { |
| 139 | keys = append(keys, "style", "default") |
| 140 | } |
| 141 | args = append(args, "--key") |
| 142 | args = append(args, keys...) |
| 143 | |
| 144 | // This enables non-deterministic random seeding of the GPU FP optimization |
| 145 | // test. |
| 146 | // Not Android due to: |
| 147 | // - https://skia.googlesource.com/skia/+/5910ed347a638ded8cd4c06dbfda086695df1112/BUILD.gn#160 |
| 148 | // - https://skia.googlesource.com/skia/+/ce06e261e68848ae21cac1052abc16bc07b961bf/tests/ProcessorTest.cpp#307 |
| 149 | // Not MSAN due to: |
| 150 | // - https://skia.googlesource.com/skia/+/0ac06e47269a40c177747310a613d213c95d1d6d/infra/bots/recipe_modules/flavor/gn_flavor.py#80 |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 151 | if !b.os("Android") && !b.extraConfig("MSAN") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 152 | args = append(args, "--randomProcessorTest") |
| 153 | } |
| 154 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 155 | if b.model("Pixel3", "Pixel3a") && b.extraConfig("Vulkan") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 156 | args = append(args, "--dontReduceOpsTaskSplitting") |
| 157 | } |
| 158 | |
| 159 | threadLimit := -1 |
| 160 | const MAIN_THREAD_ONLY = 0 |
| 161 | |
| 162 | // 32-bit desktop bots tend to run out of memory, because they have relatively |
| 163 | // far more cores than RAM (e.g. 32 cores, 3G RAM). Hold them back a bit. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 164 | if b.arch("x86") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 165 | threadLimit = 4 |
| 166 | } |
| 167 | |
| 168 | // These bots run out of memory easily. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 169 | if b.model("MotoG4", "Nexus7") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 170 | threadLimit = MAIN_THREAD_ONLY |
| 171 | } |
| 172 | |
| 173 | // Avoid issues with dynamically exceeding resource cache limits. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 174 | if b.matchExtraConfig("DISCARDABLE") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 175 | threadLimit = MAIN_THREAD_ONLY |
| 176 | } |
| 177 | |
| 178 | if threadLimit >= 0 { |
| 179 | args = append(args, "--threads", strconv.Itoa(threadLimit)) |
| 180 | } |
| 181 | |
| 182 | sampleCount := 0 |
| 183 | glPrefix := "" |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 184 | if b.extraConfig("SwiftShader") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 185 | configs = append(configs, "gles", "glesdft") |
| 186 | args = append(args, "--disableDriverCorrectnessWorkarounds") |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 187 | } else if b.cpu() { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 188 | args = append(args, "--nogpu") |
| 189 | |
| 190 | configs = append(configs, "8888") |
| 191 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 192 | if b.extraConfig("BonusConfigs") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 193 | configs = []string{ |
| 194 | "g8", "565", |
| 195 | "pic-8888", "serialize-8888", |
| 196 | "f16", "srgb", "esrgb", "narrow", "enarrow", |
| 197 | "p3", "ep3", "rec2020", "erec2020"} |
| 198 | } |
| 199 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 200 | if b.extraConfig("PDF") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 201 | configs = []string{"pdf"} |
| 202 | args = append(args, "--rasterize_pdf") // Works only on Mac. |
| 203 | // Take ~forever to rasterize: |
| 204 | blacklist("pdf gm _ lattice2") |
| 205 | blacklist("pdf gm _ hairmodes") |
| 206 | blacklist("pdf gm _ longpathdash") |
| 207 | } |
| 208 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 209 | } else if b.gpu() { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 210 | args = append(args, "--nocpu") |
| 211 | |
| 212 | // Add in either gles or gl configs to the canonical set based on OS |
| 213 | sampleCount = 8 |
| 214 | glPrefix = "gl" |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 215 | if b.os("Android", "iOS") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 216 | sampleCount = 4 |
| 217 | // We want to test the OpenGL config not the GLES config on the Shield |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 218 | if !b.model("NVIDIA_Shield") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 219 | glPrefix = "gles" |
| 220 | } |
| 221 | // MSAA is disabled on Pixel3a (https://b.corp.google.com/issues/143074513). |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 222 | if b.model("Pixel3a") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 223 | sampleCount = 0 |
| 224 | } |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 225 | } else if b.matchGpu("Intel") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 226 | // MSAA doesn't work well on Intel GPUs chromium:527565, chromium:983926 |
| 227 | sampleCount = 0 |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 228 | } else if b.os("ChromeOS") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 229 | glPrefix = "gles" |
| 230 | } |
| 231 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 232 | if b.extraConfig("NativeFonts") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 233 | configs = append(configs, glPrefix) |
| 234 | } else { |
| 235 | configs = append(configs, glPrefix, glPrefix+"dft", glPrefix+"srgb") |
| 236 | if sampleCount > 0 { |
| 237 | configs = append(configs, fmt.Sprintf("%smsaa%d", glPrefix, sampleCount)) |
| 238 | } |
| 239 | } |
| 240 | |
| 241 | // The Tegra3 doesn't support MSAA |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 242 | if b.gpu("Tegra3") || |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 243 | // We aren't interested in fixing msaa bugs on current iOS devices. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 244 | b.model("iPad4", "iPadPro", "iPhone6", "iPhone7") || |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 245 | // skia:5792 |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 246 | b.gpu("IntelHD530", "IntelIris540") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 247 | configs = removeContains(configs, "msaa") |
| 248 | } |
| 249 | |
| 250 | // We want to test both the OpenGL config and the GLES config on Linux Intel: |
| 251 | // GL is used by Chrome, GLES is used by ChromeOS. |
| 252 | // Also do the Ganesh threading verification test (render with and without |
| 253 | // worker threads, using only the SW path renderer, and compare the results). |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 254 | if b.matchGpu("Intel") && b.isLinux() { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 255 | configs = append(configs, "gles", "glesdft", "glessrgb", "gltestthreading") |
| 256 | // skbug.com/6333, skbug.com/6419, skbug.com/6702 |
| 257 | blacklist("gltestthreading gm _ lcdblendmodes") |
| 258 | blacklist("gltestthreading gm _ lcdoverlap") |
| 259 | blacklist("gltestthreading gm _ textbloblooper") |
| 260 | // All of these GMs are flaky, too: |
| 261 | blacklist("gltestthreading gm _ bleed_alpha_bmp") |
| 262 | blacklist("gltestthreading gm _ bleed_alpha_bmp_shader") |
| 263 | blacklist("gltestthreading gm _ bleed_alpha_image") |
| 264 | blacklist("gltestthreading gm _ bleed_alpha_image_shader") |
| 265 | blacklist("gltestthreading gm _ savelayer_with_backdrop") |
| 266 | blacklist("gltestthreading gm _ persp_shaders_bw") |
| 267 | blacklist("gltestthreading gm _ dftext_blob_persp") |
| 268 | blacklist("gltestthreading gm _ dftext") |
| 269 | // skbug.com/7523 - Flaky on various GPUs |
| 270 | blacklist("gltestthreading gm _ orientation") |
| 271 | // These GMs only differ in the low bits |
| 272 | blacklist("gltestthreading gm _ stroketext") |
| 273 | blacklist("gltestthreading gm _ draw_image_set") |
| 274 | } |
| 275 | |
| 276 | // CommandBuffer bot *only* runs the command_buffer config. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 277 | if b.extraConfig("CommandBuffer") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 278 | configs = []string{"commandbuffer"} |
| 279 | } |
| 280 | |
| 281 | // ANGLE bot *only* runs the angle configs |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 282 | if b.extraConfig("ANGLE") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 283 | configs = []string{"angle_d3d11_es2", |
| 284 | "angle_d3d9_es2", |
| 285 | "angle_gl_es2", |
| 286 | "angle_d3d11_es3"} |
| 287 | if sampleCount > 0 { |
| 288 | configs = append(configs, fmt.Sprintf("angle_d3d11_es2_msaa%d", sampleCount)) |
| 289 | configs = append(configs, fmt.Sprintf("angle_d3d11_es3_msaa%d", sampleCount)) |
| 290 | } |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 291 | if b.model("LenovoYogaC630") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 292 | // LenovoYogaC630 only supports D3D11, and to save time, we only test ES3 |
| 293 | configs = []string{ |
| 294 | "angle_d3d11_es3", |
| 295 | fmt.Sprintf("angle_d3d11_es3_msaa%d", sampleCount), |
| 296 | } |
| 297 | } |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 298 | if b.matchGpu("GTX", "Quadro") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 299 | // See skia:7823 and chromium:693090. |
| 300 | configs = append(configs, "angle_gl_es3") |
| 301 | if sampleCount > 0 { |
| 302 | configs = append(configs, fmt.Sprintf("angle_gl_es2_msaa%d", sampleCount)) |
| 303 | configs = append(configs, fmt.Sprintf("angle_gl_es3_msaa%d", sampleCount)) |
| 304 | } |
| 305 | } |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 306 | if b.model("NUC5i7RYH") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 307 | // skbug.com/7376 |
| 308 | blacklist("_ test _ ProcessorCloneTest") |
| 309 | } |
| 310 | } |
| 311 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 312 | if b.model("AndroidOne", "GalaxyS6") || (b.model("Nexus5", "Nexus7")) { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 313 | // skbug.com/9019 |
| 314 | blacklist("_ test _ ProcessorCloneTest") |
| 315 | blacklist("_ test _ Programs") |
| 316 | blacklist("_ test _ ProcessorOptimizationValidationTest") |
| 317 | } |
| 318 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 319 | if b.extraConfig("CommandBuffer") && b.model("MacBook10.1") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 320 | // skbug.com/9235 |
| 321 | blacklist("_ test _ Programs") |
| 322 | } |
| 323 | |
| 324 | // skbug.com/9033 - these devices run out of memory on this test |
| 325 | // when opList splitting reduction is enabled |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 326 | if b.gpu() && (b.model("Nexus7", "NVIDIA_Shield", "Nexus5x") || |
| 327 | (b.os("Win10") && b.gpu("GTX660") && b.extraConfig("Vulkan"))) { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 328 | blacklist("_", "gm", "_", "savelayer_clipmask") |
| 329 | } |
| 330 | |
| 331 | // skbug.com/9123 |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 332 | if b.extraConfig("CommandBuffer") && b.gpu("IntelIris5100") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 333 | blacklist("_", "test", "_", "AsyncReadPixels") |
| 334 | } |
| 335 | |
| 336 | // skbug.com/9043 - these devices render this test incorrectly |
| 337 | // when opList splitting reduction is enabled |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 338 | if b.gpu() && b.extraConfig("Vulkan") && (b.gpu("RadeonR9M470X", "RadeonHD7770")) { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 339 | blacklist("_", "tests", "_", "VkDrawableImportTest") |
| 340 | } |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 341 | if b.extraConfig("Vulkan") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 342 | configs = []string{"vk"} |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 343 | if b.os("Android") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 344 | configs = append(configs, "vkmsaa4") |
| 345 | } else { |
| 346 | // MSAA doesn't work well on Intel GPUs chromium:527565, chromium:983926, skia:9023 |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 347 | if !b.matchGpu("Intel") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 348 | configs = append(configs, "vkmsaa8") |
| 349 | } |
| 350 | } |
| 351 | } |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 352 | if b.extraConfig("Metal") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 353 | configs = []string{"mtl"} |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 354 | if b.os("iOS") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 355 | configs = append(configs, "mtlmsaa4") |
| 356 | } else { |
| 357 | // MSAA doesn't work well on Intel GPUs chromium:527565, chromium:983926 |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 358 | if !b.matchGpu("Intel") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 359 | configs = append(configs, "mtlmsaa8") |
| 360 | } |
| 361 | } |
| 362 | } |
| 363 | |
| 364 | // Test 1010102 on our Linux/NVIDIA bots and the persistent cache config |
| 365 | // on the GL bots. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 366 | if b.gpu("QuadroP400") && !b.extraConfig("PreAbandonGpuContext") && !b.extraConfig("TSAN") && b.isLinux() { |
| 367 | if b.extraConfig("Vulkan") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 368 | configs = append(configs, "vk1010102") |
| 369 | // Decoding transparent images to 1010102 just looks bad |
| 370 | blacklist("vk1010102 image _ _") |
| 371 | } else { |
| 372 | configs = append(configs, "gl1010102", "gltestpersistentcache", "gltestglslcache", "gltestprecompile") |
| 373 | // Decoding transparent images to 1010102 just looks bad |
| 374 | blacklist("gl1010102 image _ _") |
| 375 | // These tests produce slightly different pixels run to run on NV. |
| 376 | blacklist("gltestpersistentcache gm _ atlastext") |
| 377 | blacklist("gltestpersistentcache gm _ dftext") |
| 378 | blacklist("gltestpersistentcache gm _ glyph_pos_h_b") |
| 379 | blacklist("gltestglslcache gm _ atlastext") |
| 380 | blacklist("gltestglslcache gm _ dftext") |
| 381 | blacklist("gltestglslcache gm _ glyph_pos_h_b") |
| 382 | blacklist("gltestprecompile gm _ atlastext") |
| 383 | blacklist("gltestprecompile gm _ dftext") |
| 384 | blacklist("gltestprecompile gm _ glyph_pos_h_b") |
| 385 | // Tessellation shaders do not yet participate in the persistent cache. |
| 386 | blacklist("gltestpersistentcache gm _ tessellation") |
| 387 | blacklist("gltestglslcache gm _ tessellation") |
| 388 | blacklist("gltestprecompile gm _ tessellation") |
| 389 | } |
| 390 | } |
| 391 | |
| 392 | // We also test the SkSL precompile config on Pixel2XL as a representative |
| 393 | // Android device - this feature is primarily used by Flutter. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 394 | if b.model("Pixel2XL") && !b.extraConfig("Vulkan") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 395 | configs = append(configs, "glestestprecompile") |
| 396 | } |
| 397 | |
| 398 | // Test rendering to wrapped dsts on a few bots |
| 399 | // Also test "glenarrow", which hits F16 surfaces and F16 vertex colors. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 400 | if b.extraConfig("BonusConfigs") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 401 | configs = []string{"glbetex", "glbert", "glenarrow"} |
| 402 | } |
| 403 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 404 | if b.os("ChromeOS") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 405 | // Just run GLES for now - maybe add gles_msaa4 in the future |
| 406 | configs = []string{"gles"} |
| 407 | } |
| 408 | |
| 409 | // Test coverage counting path renderer. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 410 | if b.extraConfig("CCPR") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 411 | configs = filter(configs, "gl", "gles") |
| 412 | args = append(args, "--pr", "ccpr", "--cc", "true", "--cachePathMasks", "false") |
| 413 | } |
| 414 | |
| 415 | // Test GPU tessellation path renderer. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 416 | if b.extraConfig("GpuTess") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 417 | configs = []string{glPrefix + "msaa4"} |
| 418 | args = append(args, "--pr", "gtess") |
| 419 | } |
| 420 | |
| 421 | // Test non-nvpr on NVIDIA. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 422 | if b.extraConfig("NonNVPR") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 423 | configs = []string{"gl", "glmsaa4"} |
| 424 | args = append(args, "--pr", "~nvpr") |
| 425 | } |
| 426 | |
| 427 | // DDL is a GPU-only feature |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 428 | if b.extraConfig("DDL1") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 429 | // This bot generates gl and vk comparison images for the large skps |
| 430 | configs = filter(configs, "gl", "vk", "mtl") |
| 431 | args = append(args, "--skpViewportSize", "2048") |
| 432 | args = append(args, "--pr", "~small") |
| 433 | } |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 434 | if b.extraConfig("DDL3") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 435 | // This bot generates the ddl-gl and ddl-vk images for the |
| 436 | // large skps and the gms |
| 437 | ddlConfigs := prefix(filter(configs, "gl", "vk", "mtl"), "ddl-") |
| 438 | ddl2Configs := prefix(filter(configs, "gl", "vk", "mtl"), "ddl2-") |
| 439 | configs = append(ddlConfigs, ddl2Configs...) |
| 440 | args = append(args, "--skpViewportSize", "2048") |
| 441 | args = append(args, "--gpuThreads", "0") |
| 442 | } |
| 443 | } |
| 444 | |
| 445 | // Sharding. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 446 | tf := b.parts["test_filter"] |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 447 | if tf != "" && tf != "All" { |
| 448 | // Expected format: shard_XX_YY |
| 449 | split := strings.Split(tf, "_") |
| 450 | if len(split) == 3 { |
| 451 | args = append(args, "--shard", split[1]) |
| 452 | args = append(args, "--shards", split[2]) |
| 453 | } else { |
| 454 | glog.Fatalf("Invalid task name - bad shards: %s", tf) |
| 455 | } |
| 456 | } |
| 457 | |
| 458 | args = append(args, "--config") |
| 459 | args = append(args, configs...) |
| 460 | |
| 461 | removeFromArgs := func(arg string) { |
| 462 | args = remove(args, arg) |
| 463 | } |
| 464 | |
| 465 | // Run tests, gms, and image decoding tests everywhere. |
| 466 | args = append(args, "--src", "tests", "gm", "image", "lottie", "colorImage", "svg", "skp") |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 467 | if b.gpu() { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 468 | // Don't run the "svgparse_*" svgs on GPU. |
| 469 | blacklist("_ svg _ svgparse_") |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 470 | } else if b.Name == "Test-Debian9-Clang-GCE-CPU-AVX2-x86_64-Debug-All-ASAN" { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 471 | // Only run the CPU SVGs on 8888. |
| 472 | blacklist("~8888 svg _ _") |
| 473 | } else { |
| 474 | // On CPU SVGs we only care about parsing. Only run them on the above bot. |
| 475 | removeFromArgs("svg") |
| 476 | } |
| 477 | |
| 478 | // Eventually I'd like these to pass, but for now just skip 'em. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 479 | if b.extraConfig("SK_FORCE_RASTER_PIPELINE_BLITTER") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 480 | removeFromArgs("tests") |
| 481 | } |
| 482 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 483 | if b.extraConfig("NativeFonts") { // images won't exercise native font integration :) |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 484 | removeFromArgs("image") |
| 485 | removeFromArgs("colorImage") |
| 486 | } |
| 487 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 488 | if b.matchExtraConfig("DDL", "PDF") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 489 | // The DDL and PDF bots just render the large skps and the gms |
| 490 | removeFromArgs("tests") |
| 491 | removeFromArgs("image") |
| 492 | removeFromArgs("colorImage") |
| 493 | removeFromArgs("svg") |
| 494 | } else { |
| 495 | // No other bots render the .skps. |
| 496 | removeFromArgs("skp") |
| 497 | } |
| 498 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 499 | if b.extraConfig("Lottie") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 500 | // Only run the lotties on Lottie bots. |
| 501 | removeFromArgs("tests") |
| 502 | removeFromArgs("gm") |
| 503 | removeFromArgs("image") |
| 504 | removeFromArgs("colorImage") |
| 505 | removeFromArgs("svg") |
| 506 | removeFromArgs("skp") |
| 507 | } else { |
| 508 | removeFromArgs("lottie") |
| 509 | } |
| 510 | |
| 511 | // TODO: ??? |
| 512 | blacklist("f16 _ _ dstreadshuffle") |
| 513 | blacklist("glsrgb image _ _") |
| 514 | blacklist("glessrgb image _ _") |
| 515 | |
| 516 | // --src image --config g8 means "decode into Gray8", which isn't supported. |
| 517 | blacklist("g8 image _ _") |
| 518 | blacklist("g8 colorImage _ _") |
| 519 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 520 | if b.extraConfig("Valgrind") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 521 | // These take 18+ hours to run. |
| 522 | blacklist("pdf gm _ fontmgr_iter") |
| 523 | blacklist("pdf _ _ PANO_20121023_214540.jpg") |
| 524 | blacklist("pdf skp _ worldjournal") |
| 525 | blacklist("pdf skp _ desk_baidu.skp") |
| 526 | blacklist("pdf skp _ desk_wikipedia.skp") |
| 527 | blacklist("_ svg _ _") |
| 528 | // skbug.com/9171 and 8847 |
| 529 | blacklist("_ test _ InitialTextureClear") |
| 530 | } |
| 531 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 532 | if b.model("TecnoSpark3Pro") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 533 | // skbug.com/9421 |
| 534 | blacklist("_ test _ InitialTextureClear") |
| 535 | } |
| 536 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 537 | if b.os("iOS") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 538 | blacklist(glPrefix + " skp _ _") |
| 539 | } |
| 540 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 541 | if b.matchOs("Mac", "iOS") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 542 | // CG fails on questionable bmps |
| 543 | blacklist("_ image gen_platf rgba32abf.bmp") |
| 544 | blacklist("_ image gen_platf rgb24prof.bmp") |
| 545 | blacklist("_ image gen_platf rgb24lprof.bmp") |
| 546 | blacklist("_ image gen_platf 8bpp-pixeldata-cropped.bmp") |
| 547 | blacklist("_ image gen_platf 4bpp-pixeldata-cropped.bmp") |
| 548 | blacklist("_ image gen_platf 32bpp-pixeldata-cropped.bmp") |
| 549 | blacklist("_ image gen_platf 24bpp-pixeldata-cropped.bmp") |
| 550 | |
| 551 | // CG has unpredictable behavior on this questionable gif |
| 552 | // It's probably using uninitialized memory |
| 553 | blacklist("_ image gen_platf frame_larger_than_image.gif") |
| 554 | |
| 555 | // CG has unpredictable behavior on incomplete pngs |
| 556 | // skbug.com/5774 |
| 557 | blacklist("_ image gen_platf inc0.png") |
| 558 | blacklist("_ image gen_platf inc1.png") |
| 559 | blacklist("_ image gen_platf inc2.png") |
| 560 | blacklist("_ image gen_platf inc3.png") |
| 561 | blacklist("_ image gen_platf inc4.png") |
| 562 | blacklist("_ image gen_platf inc5.png") |
| 563 | blacklist("_ image gen_platf inc6.png") |
| 564 | blacklist("_ image gen_platf inc7.png") |
| 565 | blacklist("_ image gen_platf inc8.png") |
| 566 | blacklist("_ image gen_platf inc9.png") |
| 567 | blacklist("_ image gen_platf inc10.png") |
| 568 | blacklist("_ image gen_platf inc11.png") |
| 569 | blacklist("_ image gen_platf inc12.png") |
| 570 | blacklist("_ image gen_platf inc13.png") |
| 571 | blacklist("_ image gen_platf inc14.png") |
| 572 | blacklist("_ image gen_platf incInterlaced.png") |
| 573 | |
| 574 | // These images fail after Mac 10.13.1 upgrade. |
| 575 | blacklist("_ image gen_platf incInterlaced.gif") |
| 576 | blacklist("_ image gen_platf inc1.gif") |
| 577 | blacklist("_ image gen_platf inc0.gif") |
| 578 | blacklist("_ image gen_platf butterfly.gif") |
| 579 | } |
| 580 | |
| 581 | // WIC fails on questionable bmps |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 582 | if b.matchOs("Win") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 583 | blacklist("_ image gen_platf pal8os2v2.bmp") |
| 584 | blacklist("_ image gen_platf pal8os2v2-16.bmp") |
| 585 | blacklist("_ image gen_platf rgba32abf.bmp") |
| 586 | blacklist("_ image gen_platf rgb24prof.bmp") |
| 587 | blacklist("_ image gen_platf rgb24lprof.bmp") |
| 588 | blacklist("_ image gen_platf 8bpp-pixeldata-cropped.bmp") |
| 589 | blacklist("_ image gen_platf 4bpp-pixeldata-cropped.bmp") |
| 590 | blacklist("_ image gen_platf 32bpp-pixeldata-cropped.bmp") |
| 591 | blacklist("_ image gen_platf 24bpp-pixeldata-cropped.bmp") |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 592 | if b.arch("x86_64") && b.cpu() { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 593 | // This GM triggers a SkSmallAllocator assert. |
| 594 | blacklist("_ gm _ composeshader_bitmap") |
| 595 | } |
| 596 | } |
| 597 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 598 | if b.matchOs("Win", "Mac") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 599 | // WIC and CG fail on arithmetic jpegs |
| 600 | blacklist("_ image gen_platf testimgari.jpg") |
| 601 | // More questionable bmps that fail on Mac, too. skbug.com/6984 |
| 602 | blacklist("_ image gen_platf rle8-height-negative.bmp") |
| 603 | blacklist("_ image gen_platf rle4-height-negative.bmp") |
| 604 | } |
| 605 | |
| 606 | // These PNGs have CRC errors. The platform generators seem to draw |
| 607 | // uninitialized memory without reporting an error, so skip them to |
| 608 | // avoid lots of images on Gold. |
| 609 | blacklist("_ image gen_platf error") |
| 610 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 611 | if b.os("Android", "iOS") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 612 | // This test crashes the N9 (perhaps because of large malloc/frees). It also |
| 613 | // is fairly slow and not platform-specific. So we just disable it on all of |
| 614 | // Android and iOS. skia:5438 |
| 615 | blacklist("_ test _ GrShape") |
| 616 | } |
| 617 | |
| 618 | if internalHardwareLabel == "5" { |
| 619 | // http://b/118312149#comment9 |
| 620 | blacklist("_ test _ SRGBReadWritePixels") |
| 621 | } |
| 622 | |
| 623 | // skia:4095 |
| 624 | badSerializeGMs := []string{ |
| 625 | "bleed_image", |
| 626 | "c_gms", |
| 627 | "colortype", |
| 628 | "colortype_xfermodes", |
| 629 | "drawfilter", |
| 630 | "fontmgr_bounds_0.75_0", |
| 631 | "fontmgr_bounds_1_-0.25", |
| 632 | "fontmgr_bounds", |
| 633 | "fontmgr_match", |
| 634 | "fontmgr_iter", |
| 635 | "imagemasksubset", |
| 636 | "wacky_yuv_formats_domain", |
| 637 | "imagemakewithfilter", |
| 638 | "imagemakewithfilter_crop", |
| 639 | "imagemakewithfilter_crop_ref", |
| 640 | "imagemakewithfilter_ref", |
| 641 | } |
| 642 | |
| 643 | // skia:5589 |
| 644 | badSerializeGMs = append(badSerializeGMs, |
| 645 | "bitmapfilters", |
| 646 | "bitmapshaders", |
| 647 | "bleed", |
| 648 | "bleed_alpha_bmp", |
| 649 | "bleed_alpha_bmp_shader", |
| 650 | "convex_poly_clip", |
| 651 | "extractalpha", |
| 652 | "filterbitmap_checkerboard_32_32_g8", |
| 653 | "filterbitmap_image_mandrill_64", |
| 654 | "shadows", |
| 655 | "simpleaaclip_aaclip", |
| 656 | ) |
| 657 | |
| 658 | // skia:5595 |
| 659 | badSerializeGMs = append(badSerializeGMs, |
| 660 | "composeshader_bitmap", |
| 661 | "scaled_tilemodes_npot", |
| 662 | "scaled_tilemodes", |
| 663 | ) |
| 664 | |
| 665 | // skia:5778 |
| 666 | badSerializeGMs = append(badSerializeGMs, "typefacerendering_pfaMac") |
| 667 | // skia:5942 |
| 668 | badSerializeGMs = append(badSerializeGMs, "parsedpaths") |
| 669 | |
| 670 | // these use a custom image generator which doesn't serialize |
| 671 | badSerializeGMs = append(badSerializeGMs, "ImageGeneratorExternal_rect") |
| 672 | badSerializeGMs = append(badSerializeGMs, "ImageGeneratorExternal_shader") |
| 673 | |
| 674 | // skia:6189 |
| 675 | badSerializeGMs = append(badSerializeGMs, "shadow_utils") |
| 676 | |
| 677 | // skia:7938 |
| 678 | badSerializeGMs = append(badSerializeGMs, "persp_images") |
| 679 | |
| 680 | // Not expected to round trip encoding/decoding. |
| 681 | badSerializeGMs = append(badSerializeGMs, "all_bitmap_configs") |
| 682 | badSerializeGMs = append(badSerializeGMs, "makecolorspace") |
| 683 | badSerializeGMs = append(badSerializeGMs, "readpixels") |
| 684 | badSerializeGMs = append(badSerializeGMs, "draw_image_set_rect_to_rect") |
| 685 | badSerializeGMs = append(badSerializeGMs, "compositor_quads_shader") |
| 686 | badSerializeGMs = append(badSerializeGMs, "wacky_yuv_formats_qtr") |
| 687 | |
| 688 | // This GM forces a path to be convex. That property doesn't survive |
| 689 | // serialization. |
| 690 | badSerializeGMs = append(badSerializeGMs, "analytic_antialias_convex") |
| 691 | |
| 692 | for _, test := range badSerializeGMs { |
| 693 | blacklist("serialize-8888", "gm", "_", test) |
| 694 | } |
| 695 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 696 | if !b.matchOs("Mac") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 697 | for _, test := range []string{"bleed_alpha_image", "bleed_alpha_image_shader"} { |
| 698 | blacklist("serialize-8888", "gm", "_", test) |
| 699 | } |
| 700 | } |
| 701 | // It looks like we skip these only for out-of-memory concerns. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 702 | if b.matchOs("Win", "Android") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 703 | for _, test := range []string{"verylargebitmap", "verylarge_picture_image"} { |
| 704 | blacklist("serialize-8888", "gm", "_", test) |
| 705 | } |
| 706 | } |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 707 | if b.matchOs("Mac") && b.cpu() { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 708 | // skia:6992 |
| 709 | blacklist("pic-8888", "gm", "_", "encode-platform") |
| 710 | blacklist("serialize-8888", "gm", "_", "encode-platform") |
| 711 | } |
| 712 | |
| 713 | // skia:4769 |
| 714 | blacklist("pic-8888", "gm", "_", "drawfilter") |
| 715 | |
| 716 | // skia:4703 |
| 717 | for _, test := range []string{"image-cacherator-from-picture", |
| 718 | "image-cacherator-from-raster", |
| 719 | "image-cacherator-from-ctable"} { |
| 720 | blacklist("pic-8888", "gm", "_", test) |
| 721 | blacklist("serialize-8888", "gm", "_", test) |
| 722 | } |
| 723 | |
| 724 | // GM that requires raster-backed canvas |
| 725 | for _, test := range []string{"complexclip4_bw", "complexclip4_aa", "p3", |
| 726 | "async_rescale_and_read_text_up_large", |
| 727 | "async_rescale_and_read_text_up", |
| 728 | "async_rescale_and_read_text_down", |
| 729 | "async_rescale_and_read_dog_up", |
| 730 | "async_rescale_and_read_dog_down", |
| 731 | "async_rescale_and_read_rose", |
| 732 | "async_rescale_and_read_no_bleed"} { |
| 733 | blacklist("pic-8888", "gm", "_", test) |
| 734 | blacklist("serialize-8888", "gm", "_", test) |
| 735 | |
| 736 | // GM requires canvas->makeSurface() to return a valid surface. |
| 737 | // TODO(borenet): These should be just outside of this block but are |
| 738 | // left here to match the recipe which has an indentation bug. |
| 739 | blacklist("pic-8888", "gm", "_", "blurrect_compare") |
| 740 | blacklist("serialize-8888", "gm", "_", "blurrect_compare") |
| 741 | } |
| 742 | |
| 743 | // Extensions for RAW images |
| 744 | r := []string{ |
| 745 | "arw", "cr2", "dng", "nef", "nrw", "orf", "raf", "rw2", "pef", "srw", |
| 746 | "ARW", "CR2", "DNG", "NEF", "NRW", "ORF", "RAF", "RW2", "PEF", "SRW", |
| 747 | } |
| 748 | |
| 749 | // skbug.com/4888 |
| 750 | // Blacklist RAW images (and a few large PNGs) on GPU bots |
| 751 | // until we can resolve failures. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 752 | if b.gpu() { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 753 | blacklist("_ image _ interlaced1.png") |
| 754 | blacklist("_ image _ interlaced2.png") |
| 755 | blacklist("_ image _ interlaced3.png") |
| 756 | for _, rawExt := range r { |
| 757 | blacklist(fmt.Sprintf("_ image _ .%s", rawExt)) |
| 758 | } |
| 759 | } |
| 760 | |
| 761 | // Blacklist memory intensive tests on 32-bit bots. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 762 | if b.os("Win8") && b.arch("x86") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 763 | blacklist("_ image f16 _") |
| 764 | blacklist("_ image _ abnormal.wbmp") |
| 765 | blacklist("_ image _ interlaced1.png") |
| 766 | blacklist("_ image _ interlaced2.png") |
| 767 | blacklist("_ image _ interlaced3.png") |
| 768 | for _, rawExt := range r { |
| 769 | blacklist(fmt.Sprintf("_ image _ .%s", rawExt)) |
| 770 | } |
| 771 | } |
| 772 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 773 | if b.model("Nexus5", "Nexus5x") && b.gpu() { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 774 | // skia:5876 |
| 775 | blacklist("_", "gm", "_", "encode-platform") |
| 776 | } |
| 777 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 778 | if b.model("AndroidOne") && b.gpu() { // skia:4697, skia:4704, skia:4694, skia:4705 |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 779 | blacklist("_", "gm", "_", "bigblurs") |
| 780 | blacklist("_", "gm", "_", "bleed") |
| 781 | blacklist("_", "gm", "_", "bleed_alpha_bmp") |
| 782 | blacklist("_", "gm", "_", "bleed_alpha_bmp_shader") |
| 783 | blacklist("_", "gm", "_", "bleed_alpha_image") |
| 784 | blacklist("_", "gm", "_", "bleed_alpha_image_shader") |
| 785 | blacklist("_", "gm", "_", "bleed_image") |
| 786 | blacklist("_", "gm", "_", "dropshadowimagefilter") |
| 787 | blacklist("_", "gm", "_", "filterfastbounds") |
| 788 | blacklist(glPrefix, "gm", "_", "imageblurtiled") |
| 789 | blacklist("_", "gm", "_", "imagefiltersclipped") |
| 790 | blacklist("_", "gm", "_", "imagefiltersscaled") |
| 791 | blacklist("_", "gm", "_", "imageresizetiled") |
| 792 | blacklist("_", "gm", "_", "matrixconvolution") |
| 793 | blacklist("_", "gm", "_", "strokedlines") |
| 794 | if sampleCount > 0 { |
| 795 | glMsaaConfig := fmt.Sprintf("%smsaa%d", glPrefix, sampleCount) |
| 796 | blacklist(glMsaaConfig, "gm", "_", "imageblurtiled") |
| 797 | blacklist(glMsaaConfig, "gm", "_", "imagefiltersbase") |
| 798 | } |
| 799 | } |
| 800 | |
| 801 | match := []string{} |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 802 | if b.extraConfig("Valgrind") { // skia:3021 |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 803 | match = append(match, "~Threaded") |
| 804 | } |
| 805 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 806 | if b.extraConfig("Valgrind") && b.extraConfig("PreAbandonGpuContext") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 807 | // skia:6575 |
| 808 | match = append(match, "~multipicturedraw_") |
| 809 | } |
| 810 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 811 | if b.model("AndroidOne") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 812 | match = append(match, "~WritePixels") // skia:4711 |
| 813 | match = append(match, "~PremulAlphaRoundTrip_Gpu") // skia:7501 |
| 814 | match = append(match, "~ReimportImageTextureWithMipLevels") // skia:8090 |
| 815 | } |
| 816 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 817 | if b.model("GalaxyS6") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 818 | match = append(match, "~SpecialImage") // skia:6338 |
| 819 | match = append(match, "~skbug6653") // skia:6653 |
| 820 | } |
| 821 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 822 | if b.extraConfig("MSAN") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 823 | match = append(match, "~Once", "~Shared") // Not sure what's up with these tests. |
| 824 | } |
| 825 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 826 | if b.extraConfig("TSAN") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 827 | match = append(match, "~ReadWriteAlpha") // Flaky on TSAN-covered on nvidia bots. |
| 828 | match = append(match, "~RGBA4444TextureTest", // Flakier than they are important. |
| 829 | "~RGB565TextureTest") |
| 830 | } |
| 831 | |
| 832 | // By default, we test with GPU threading enabled, unless specifically |
| 833 | // disabled. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 834 | if b.extraConfig("NoGPUThreads") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 835 | args = append(args, "--gpuThreads", "0") |
| 836 | } |
| 837 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 838 | if b.extraConfig("Vulkan") && b.gpu("Adreno530") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 839 | // skia:5777 |
| 840 | match = append(match, "~CopySurface") |
| 841 | } |
| 842 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 843 | if b.extraConfig("Vulkan") && b.matchGpu("Adreno") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 844 | // skia:7663 |
| 845 | match = append(match, "~WritePixelsNonTextureMSAA_Gpu") |
| 846 | match = append(match, "~WritePixelsMSAA_Gpu") |
| 847 | } |
| 848 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 849 | if b.extraConfig("Vulkan") && b.isLinux() && b.gpu("IntelIris640") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 850 | match = append(match, "~VkHeapTests") // skia:6245 |
| 851 | } |
| 852 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 853 | if b.isLinux() && b.gpu("IntelIris640") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 854 | match = append(match, "~Programs") // skia:7849 |
| 855 | } |
| 856 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 857 | if b.model("TecnoSpark3Pro") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 858 | match = append(match, "~Programs") // skia:9814 |
| 859 | } |
| 860 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 861 | if b.gpu("IntelIris640", "IntelHD615", "IntelHDGraphics615") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 862 | match = append(match, "~^SRGBReadWritePixels$") // skia:9225 |
| 863 | } |
| 864 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 865 | if b.extraConfig("Vulkan") && b.isLinux() && b.gpu("IntelHD405") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 866 | // skia:7322 |
| 867 | blacklist("vk", "gm", "_", "skbug_257") |
| 868 | blacklist("vk", "gm", "_", "filltypespersp") |
| 869 | match = append(match, "~^ClearOp$") |
| 870 | match = append(match, "~^CopySurface$") |
| 871 | match = append(match, "~^ImageNewShader_GPU$") |
| 872 | match = append(match, "~^InitialTextureClear$") |
| 873 | match = append(match, "~^PinnedImageTest$") |
| 874 | match = append(match, "~^ReadPixels_Gpu$") |
| 875 | match = append(match, "~^ReadPixels_Texture$") |
| 876 | match = append(match, "~^SRGBReadWritePixels$") |
| 877 | match = append(match, "~^VkUploadPixelsTests$") |
| 878 | match = append(match, "~^WritePixelsNonTexture_Gpu$") |
| 879 | match = append(match, "~^WritePixelsNonTextureMSAA_Gpu$") |
| 880 | match = append(match, "~^WritePixels_Gpu$") |
| 881 | match = append(match, "~^WritePixelsMSAA_Gpu$") |
| 882 | } |
| 883 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 884 | if b.extraConfig("Vulkan") && b.gpu("GTX660") && b.matchOs("Win") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 885 | // skbug.com/8047 |
| 886 | match = append(match, "~FloatingPointTextureTest$") |
| 887 | } |
| 888 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 889 | if b.extraConfig("Metal") && b.gpu("RadeonHD8870M") && b.matchOs("Mac") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 890 | // skia:9255 |
| 891 | match = append(match, "~WritePixelsNonTextureMSAA_Gpu") |
| 892 | } |
| 893 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 894 | if b.extraConfig("ANGLE") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 895 | // skia:7835 |
| 896 | match = append(match, "~BlurMaskBiggerThanDest") |
| 897 | } |
| 898 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 899 | if b.gpu("IntelIris6100") && b.extraConfig("ANGLE") && !b.debug() { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 900 | // skia:7376 |
| 901 | match = append(match, "~^ProcessorOptimizationValidationTest$") |
| 902 | } |
| 903 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 904 | if b.gpu("IntelIris6100", "IntelHD4400") && b.extraConfig("ANGLE") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 905 | // skia:6857 |
| 906 | blacklist("angle_d3d9_es2", "gm", "_", "lighting") |
| 907 | } |
| 908 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 909 | if b.gpu("PowerVRGX6250") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 910 | match = append(match, "~gradients_view_perspective_nodither") //skia:6972 |
| 911 | } |
| 912 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 913 | if b.arch("arm") && b.extraConfig("ASAN") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 914 | // TODO: can we run with env allocator_may_return_null=1 instead? |
| 915 | match = append(match, "~BadImage") |
| 916 | } |
| 917 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 918 | if b.matchOs("Mac") && b.gpu("IntelHD6000") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 919 | // skia:7574 |
| 920 | match = append(match, "~^ProcessorCloneTest$") |
| 921 | match = append(match, "~^GrMeshTest$") |
| 922 | } |
| 923 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 924 | if b.matchOs("Mac") && b.gpu("IntelHD615") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 925 | // skia:7603 |
| 926 | match = append(match, "~^GrMeshTest$") |
| 927 | } |
| 928 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 929 | if b.model("LenovoYogaC630") && b.extraConfig("ANGLE") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 930 | // skia:9275 |
| 931 | blacklist("_", "tests", "_", "Programs") |
| 932 | // skia:8976 |
| 933 | blacklist("_", "tests", "_", "GrDefaultPathRendererTest") |
| 934 | // https://bugs.chromium.org/p/angleproject/issues/detail?id=3414 |
| 935 | blacklist("_", "tests", "_", "PinnedImageTest") |
| 936 | } |
| 937 | |
| 938 | if len(blacklisted) > 0 { |
| 939 | args = append(args, "--blacklist") |
| 940 | args = append(args, blacklisted...) |
| 941 | } |
| 942 | |
| 943 | if len(match) > 0 { |
| 944 | args = append(args, "--match") |
| 945 | args = append(args, match...) |
| 946 | } |
| 947 | |
| 948 | // These bots run out of memory running RAW codec tests. Do not run them in |
| 949 | // parallel |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 950 | // TODO(borenet): Previously this was `'Nexus5' in bot or 'Nexus9' in bot` |
| 951 | // which also matched 'Nexus5x'. I added That here to maintain the |
| 952 | // existing behavior, but we should verify that it's needed. |
| 953 | if b.model("Nexus5", "Nexus5x", "Nexus9") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 954 | args = append(args, "--noRAW_threading") |
| 955 | } |
| 956 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 957 | if b.extraConfig("FSAA") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 958 | args = append(args, "--analyticAA", "false") |
| 959 | } |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 960 | if b.extraConfig("FAAA") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 961 | args = append(args, "--forceAnalyticAA") |
| 962 | } |
| 963 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 964 | if !b.extraConfig("NativeFonts") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 965 | args = append(args, "--nonativeFonts") |
| 966 | } |
| 967 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 968 | if b.extraConfig("GDI") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 969 | args = append(args, "--gdi") |
| 970 | } |
| 971 | |
| 972 | // Let's make all bots produce verbose output by default. |
| 973 | args = append(args, "--verbose") |
| 974 | |
| 975 | // See skia:2789. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 976 | if b.extraConfig("AbandonGpuContext") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 977 | args = append(args, "--abandonGpuContext") |
| 978 | } |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 979 | if b.extraConfig("PreAbandonGpuContext") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 980 | args = append(args, "--preAbandonGpuContext") |
| 981 | } |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 982 | if b.extraConfig("ReleaseAndAbandonGpuContext") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 983 | args = append(args, "--releaseAndAbandonGpuContext") |
| 984 | } |
Eric Boren | 457c1eb | 2020-03-16 13:49:33 -0400 | [diff] [blame] | 985 | |
| 986 | // Finalize the DM flags and properties. |
| 987 | b.recipeProp("dm_flags", marshalJson(args)) |
| 988 | b.recipeProp("dm_properties", marshalJson(properties)) |
Eric Boren | 59e7496 | 2020-03-23 09:17:24 -0400 | [diff] [blame] | 989 | |
| 990 | // Add properties indicating which assets the task should use. |
| 991 | if b.matchExtraConfig("Lottie") { |
Eric Boren | 0f9d5bd | 2020-03-23 09:57:05 -0400 | [diff] [blame^] | 992 | b.asset("lottie-samples") |
Eric Boren | 59e7496 | 2020-03-23 09:17:24 -0400 | [diff] [blame] | 993 | b.recipeProp("lotties", "true") |
| 994 | } else { |
| 995 | b.asset("skimage") |
| 996 | b.recipeProp("images", "true") |
| 997 | b.asset("skp") |
| 998 | b.recipeProp("skps", "true") |
| 999 | b.asset("svg") |
| 1000 | b.recipeProp("svgs", "true") |
| 1001 | } |
| 1002 | b.recipeProp("do_upload", fmt.Sprintf("%t", b.doUpload())) |
| 1003 | b.recipeProp("resources", "true") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 1004 | } |