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. |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 21 | ignored := []string{"role", "test_filter"} |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 22 | keys := make([]string, 0, len(parts)) |
| 23 | for key := range parts { |
| 24 | found := false |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 25 | for _, b := range ignored { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 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{} |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 63 | skipped := []string{} |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 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 | } |
Robert Phillips | 2329db1 | 2020-05-04 09:20:00 -0400 | [diff] [blame] | 104 | suffix := func(slice []string, sfx string) []string { |
| 105 | rv := make([]string, 0, len(slice)) |
| 106 | for _, e := range slice { |
| 107 | rv = append(rv, e+sfx) |
| 108 | } |
| 109 | return rv |
| 110 | } |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 111 | |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 112 | skip := func(quad ...string) { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 113 | if len(quad) == 1 { |
| 114 | quad = strings.Fields(quad[0]) |
| 115 | } |
| 116 | if len(quad) != 4 { |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 117 | log.Fatalf("Invalid value for --skip: %+v", quad) |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 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:])) { |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 126 | skipped = append(skipped, config, src, options, name) |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 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") { |
Robert Phillips | 3429865 | 2020-08-12 12:38:59 -0400 | [diff] [blame] | 136 | // 'DDL' style means "--skpViewportSize 2048" |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 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 | |
Mike Klein | 4ba8d1f | 2020-04-07 12:14:48 -0500 | [diff] [blame] | 192 | if b.extraConfig("SkVM") { |
| 193 | args = append(args, "--skvm") |
| 194 | } |
| 195 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 196 | if b.extraConfig("BonusConfigs") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 197 | configs = []string{ |
| 198 | "g8", "565", |
| 199 | "pic-8888", "serialize-8888", |
| 200 | "f16", "srgb", "esrgb", "narrow", "enarrow", |
| 201 | "p3", "ep3", "rec2020", "erec2020"} |
| 202 | } |
| 203 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 204 | if b.extraConfig("PDF") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 205 | configs = []string{"pdf"} |
| 206 | args = append(args, "--rasterize_pdf") // Works only on Mac. |
| 207 | // Take ~forever to rasterize: |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 208 | skip("pdf gm _ lattice2") |
| 209 | skip("pdf gm _ hairmodes") |
| 210 | skip("pdf gm _ longpathdash") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 211 | } |
| 212 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 213 | } else if b.gpu() { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 214 | args = append(args, "--nocpu") |
| 215 | |
| 216 | // Add in either gles or gl configs to the canonical set based on OS |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 217 | glPrefix = "gl" |
Chris Dalton | d475659 | 2021-03-31 09:14:16 -0600 | [diff] [blame^] | 218 | // Use 4x MSAA for all our testing. It's more consistent and 8x MSAA is nondeterministic (by |
| 219 | // design) on NVIDIA hardware. The problem is especially bad on ANGLE. skia:6813 skia:6545 |
| 220 | sampleCount = 4 |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 221 | if b.os("Android", "iOS") { |
Chris Dalton | d475659 | 2021-03-31 09:14:16 -0600 | [diff] [blame^] | 222 | glPrefix = "gles" |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 223 | // MSAA is disabled on Pixel3a (https://b.corp.google.com/issues/143074513). |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 224 | if b.model("Pixel3a") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 225 | sampleCount = 0 |
| 226 | } |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 227 | } else if b.matchGpu("Intel") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 228 | // MSAA doesn't work well on Intel GPUs chromium:527565, chromium:983926 |
| 229 | sampleCount = 0 |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 230 | } else if b.os("ChromeOS") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 231 | glPrefix = "gles" |
| 232 | } |
| 233 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 234 | if b.extraConfig("NativeFonts") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 235 | configs = append(configs, glPrefix) |
| 236 | } else { |
| 237 | configs = append(configs, glPrefix, glPrefix+"dft", glPrefix+"srgb") |
| 238 | if sampleCount > 0 { |
| 239 | configs = append(configs, fmt.Sprintf("%smsaa%d", glPrefix, sampleCount)) |
| 240 | } |
| 241 | } |
| 242 | |
| 243 | // The Tegra3 doesn't support MSAA |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 244 | if b.gpu("Tegra3") || |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 245 | // We aren't interested in fixing msaa bugs on current iOS devices. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 246 | b.model("iPad4", "iPadPro", "iPhone6", "iPhone7") || |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 247 | // skia:5792 |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 248 | b.gpu("IntelHD530", "IntelIris540") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 249 | configs = removeContains(configs, "msaa") |
| 250 | } |
| 251 | |
| 252 | // We want to test both the OpenGL config and the GLES config on Linux Intel: |
| 253 | // GL is used by Chrome, GLES is used by ChromeOS. |
| 254 | // Also do the Ganesh threading verification test (render with and without |
| 255 | // worker threads, using only the SW path renderer, and compare the results). |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 256 | if b.matchGpu("Intel") && b.isLinux() { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 257 | configs = append(configs, "gles", "glesdft", "glessrgb", "gltestthreading") |
| 258 | // skbug.com/6333, skbug.com/6419, skbug.com/6702 |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 259 | skip("gltestthreading gm _ lcdblendmodes") |
| 260 | skip("gltestthreading gm _ lcdoverlap") |
| 261 | skip("gltestthreading gm _ textbloblooper") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 262 | // All of these GMs are flaky, too: |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 263 | skip("gltestthreading gm _ savelayer_with_backdrop") |
| 264 | skip("gltestthreading gm _ persp_shaders_bw") |
| 265 | skip("gltestthreading gm _ dftext_blob_persp") |
| 266 | skip("gltestthreading gm _ dftext") |
| 267 | skip("gltestthreading gm _ gpu_blur_utils") |
| 268 | skip("gltestthreading gm _ gpu_blur_utils_ref") |
| 269 | skip("gltestthreading gm _ gpu_blur_utils_subset_rect") |
| 270 | skip("gltestthreading gm _ gpu_blur_utils_subset_rect_ref") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 271 | // skbug.com/7523 - Flaky on various GPUs |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 272 | skip("gltestthreading gm _ orientation") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 273 | // These GMs only differ in the low bits |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 274 | skip("gltestthreading gm _ stroketext") |
| 275 | skip("gltestthreading gm _ draw_image_set") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 276 | } |
| 277 | |
| 278 | // CommandBuffer bot *only* runs the command_buffer config. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 279 | if b.extraConfig("CommandBuffer") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 280 | configs = []string{"commandbuffer"} |
| 281 | } |
| 282 | |
Brian Salomon | 414782d | 2020-04-17 09:34:17 -0400 | [diff] [blame] | 283 | // Dawn bot *only* runs the dawn config |
Brian Salomon | 46994e0 | 2020-03-31 19:43:29 -0400 | [diff] [blame] | 284 | if b.extraConfig("Dawn") { |
| 285 | configs = []string{"dawn"} |
| 286 | } |
| 287 | |
Brian Salomon | 414782d | 2020-04-17 09:34:17 -0400 | [diff] [blame] | 288 | // ANGLE bot *only* runs the angle configs |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 289 | if b.extraConfig("ANGLE") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 290 | configs = []string{"angle_d3d11_es2", |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 291 | "angle_gl_es2", |
| 292 | "angle_d3d11_es3"} |
| 293 | if sampleCount > 0 { |
| 294 | configs = append(configs, fmt.Sprintf("angle_d3d11_es2_msaa%d", sampleCount)) |
| 295 | configs = append(configs, fmt.Sprintf("angle_d3d11_es3_msaa%d", sampleCount)) |
| 296 | } |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 297 | if b.matchGpu("GTX", "Quadro") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 298 | // See skia:7823 and chromium:693090. |
| 299 | configs = append(configs, "angle_gl_es3") |
| 300 | if sampleCount > 0 { |
| 301 | configs = append(configs, fmt.Sprintf("angle_gl_es2_msaa%d", sampleCount)) |
| 302 | configs = append(configs, fmt.Sprintf("angle_gl_es3_msaa%d", sampleCount)) |
| 303 | } |
| 304 | } |
Brian Salomon | 414782d | 2020-04-17 09:34:17 -0400 | [diff] [blame] | 305 | if !b.matchGpu("GTX", "Quadro", "GT610") { |
| 306 | // See skia:10149 |
| 307 | configs = append(configs, "angle_d3d9_es2") |
| 308 | } |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 309 | if b.model("NUC5i7RYH") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 310 | // skbug.com/7376 |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 311 | skip("_ test _ ProcessorCloneTest") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 312 | } |
| 313 | } |
| 314 | |
Weston Tracey | 21be4f2 | 2020-05-11 10:47:17 -0400 | [diff] [blame] | 315 | if b.model("Pixelbook") { |
| 316 | // skbug.com/10232 |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 317 | skip("_ test _ ProcessorCloneTest") |
Weston Tracey | 21be4f2 | 2020-05-11 10:47:17 -0400 | [diff] [blame] | 318 | |
| 319 | } |
| 320 | |
John Stiles | 2cc126f | 2020-08-10 14:26:29 -0400 | [diff] [blame] | 321 | if b.model("AndroidOne", "GalaxyS6", "Nexus5", "Nexus7") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 322 | // skbug.com/9019 |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 323 | skip("_ test _ ProcessorCloneTest") |
| 324 | skip("_ test _ Programs") |
| 325 | skip("_ test _ ProcessorOptimizationValidationTest") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 326 | } |
| 327 | |
John Stiles | 2cc126f | 2020-08-10 14:26:29 -0400 | [diff] [blame] | 328 | if b.model("GalaxyS20") { |
| 329 | // skbug.com/10595 |
| 330 | skip("_ test _ ProcessorCloneTest") |
| 331 | } |
| 332 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 333 | if b.extraConfig("CommandBuffer") && b.model("MacBook10.1") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 334 | // skbug.com/9235 |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 335 | skip("_ test _ Programs") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 336 | } |
| 337 | |
Brian Salomon | 0f39699 | 2020-06-19 19:51:21 -0400 | [diff] [blame] | 338 | if b.extraConfig("CommandBuffer") { |
| 339 | // skbug.com/10412 |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 340 | skip("_ test _ GLBackendAllocationTest") |
Brian Salomon | 0f39699 | 2020-06-19 19:51:21 -0400 | [diff] [blame] | 341 | } |
| 342 | |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 343 | // skbug.com/9033 - these devices run out of memory on this test |
| 344 | // when opList splitting reduction is enabled |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 345 | if b.gpu() && (b.model("Nexus7", "NVIDIA_Shield", "Nexus5x") || |
| 346 | (b.os("Win10") && b.gpu("GTX660") && b.extraConfig("Vulkan"))) { |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 347 | skip("_", "gm", "_", "savelayer_clipmask") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 348 | } |
| 349 | |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 350 | // skbug.com/9043 - these devices render this test incorrectly |
| 351 | // when opList splitting reduction is enabled |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 352 | if b.gpu() && b.extraConfig("Vulkan") && (b.gpu("RadeonR9M470X", "RadeonHD7770")) { |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 353 | skip("_", "tests", "_", "VkDrawableImportTest") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 354 | } |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 355 | if b.extraConfig("Vulkan") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 356 | configs = []string{"vk"} |
Chris Dalton | d475659 | 2021-03-31 09:14:16 -0600 | [diff] [blame^] | 357 | // MSAA doesn't work well on Intel GPUs chromium:527565, chromium:983926, skia:9023 |
| 358 | if !b.matchGpu("Intel") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 359 | configs = append(configs, "vkmsaa4") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 360 | } |
| 361 | } |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 362 | if b.extraConfig("Metal") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 363 | configs = []string{"mtl"} |
Chris Dalton | d475659 | 2021-03-31 09:14:16 -0600 | [diff] [blame^] | 364 | // MSAA doesn't work well on Intel GPUs chromium:527565, chromium:983926 |
| 365 | if !b.matchGpu("Intel") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 366 | configs = append(configs, "mtlmsaa4") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 367 | } |
| 368 | } |
Jim Van Verth | 2b98f16 | 2020-06-11 15:27:35 -0400 | [diff] [blame] | 369 | if b.extraConfig("Direct3D") { |
John Stiles | 2cc126f | 2020-08-10 14:26:29 -0400 | [diff] [blame] | 370 | configs = []string{"d3d"} |
Jim Van Verth | 2b98f16 | 2020-06-11 15:27:35 -0400 | [diff] [blame] | 371 | } |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 372 | |
| 373 | // Test 1010102 on our Linux/NVIDIA bots and the persistent cache config |
| 374 | // on the GL bots. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 375 | if b.gpu("QuadroP400") && !b.extraConfig("PreAbandonGpuContext") && !b.extraConfig("TSAN") && b.isLinux() { |
| 376 | if b.extraConfig("Vulkan") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 377 | configs = append(configs, "vk1010102") |
| 378 | // Decoding transparent images to 1010102 just looks bad |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 379 | skip("vk1010102 image _ _") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 380 | } else { |
| 381 | configs = append(configs, "gl1010102", "gltestpersistentcache", "gltestglslcache", "gltestprecompile") |
| 382 | // Decoding transparent images to 1010102 just looks bad |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 383 | skip("gl1010102 image _ _") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 384 | // These tests produce slightly different pixels run to run on NV. |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 385 | skip("gltestpersistentcache gm _ atlastext") |
| 386 | skip("gltestpersistentcache gm _ dftext") |
| 387 | skip("gltestpersistentcache gm _ glyph_pos_h_b") |
| 388 | skip("gltestpersistentcache gm _ glyph_pos_h_f") |
| 389 | skip("gltestpersistentcache gm _ glyph_pos_n_f") |
| 390 | skip("gltestglslcache gm _ atlastext") |
| 391 | skip("gltestglslcache gm _ dftext") |
| 392 | skip("gltestglslcache gm _ glyph_pos_h_b") |
| 393 | skip("gltestglslcache gm _ glyph_pos_h_f") |
| 394 | skip("gltestglslcache gm _ glyph_pos_n_f") |
| 395 | skip("gltestprecompile gm _ atlastext") |
| 396 | skip("gltestprecompile gm _ dftext") |
| 397 | skip("gltestprecompile gm _ glyph_pos_h_b") |
| 398 | skip("gltestprecompile gm _ glyph_pos_h_f") |
| 399 | skip("gltestprecompile gm _ glyph_pos_n_f") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 400 | // Tessellation shaders do not yet participate in the persistent cache. |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 401 | skip("gltestpersistentcache gm _ tessellation") |
| 402 | skip("gltestglslcache gm _ tessellation") |
| 403 | skip("gltestprecompile gm _ tessellation") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 404 | } |
| 405 | } |
| 406 | |
| 407 | // We also test the SkSL precompile config on Pixel2XL as a representative |
| 408 | // Android device - this feature is primarily used by Flutter. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 409 | if b.model("Pixel2XL") && !b.extraConfig("Vulkan") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 410 | configs = append(configs, "glestestprecompile") |
| 411 | } |
| 412 | |
Robert Phillips | 8b87f4e | 2021-03-18 12:16:03 -0400 | [diff] [blame] | 413 | // Test SkSL precompile on iPhone 8 as representative iOS device |
Jim Van Verth | f54a96b | 2021-03-11 11:39:33 -0500 | [diff] [blame] | 414 | if b.model("iPhone8") && b.extraConfig("Metal") { |
Robert Phillips | 8b87f4e | 2021-03-18 12:16:03 -0400 | [diff] [blame] | 415 | configs = append(configs, "mtltestprecompile") |
Jim Van Verth | f54a96b | 2021-03-11 11:39:33 -0500 | [diff] [blame] | 416 | // avoid tests that can generate slightly different pixels per run |
| 417 | skip("mtltestprecompile gm _ atlastext") |
| 418 | skip("mtltestprecompile gm _ circular_arcs_hairline") |
| 419 | skip("mtltestprecompile gm _ dftext") |
| 420 | skip("mtltestprecompile gm _ fontmgr_bounds_1_-0.25") |
| 421 | skip("mtltestprecompile gm _ glyph_pos_h_b") |
| 422 | skip("mtltestprecompile gm _ glyph_pos_h_f") |
| 423 | skip("mtltestprecompile gm _ glyph_pos_n_f") |
| 424 | skip("mtltestprecompile gm _ strokes3") |
| 425 | skip("mtltestprecompile gm _ texel_subset_linear_mipmap_nearest_down") |
| 426 | skip("mtltestprecompile gm _ texel_subset_linear_mipmap_linear_down") |
| 427 | skip("mtltestprecompile svg _ A_large_blank_world_map_with_oceans_marked_in_blue.svg") |
| 428 | skip("mtltestprecompile svg _ Chalkboard.svg") |
Robert Phillips | 8b87f4e | 2021-03-18 12:16:03 -0400 | [diff] [blame] | 429 | skip("mtltestprecompile svg _ Ghostscript_Tiger.svg") |
Jim Van Verth | f54a96b | 2021-03-11 11:39:33 -0500 | [diff] [blame] | 430 | } |
| 431 | |
Adlai Holler | e1a7284 | 2021-03-01 17:47:07 -0600 | [diff] [blame] | 432 | if b.model(REDUCE_OPS_TASK_SPLITTING_MODELS...) { |
| 433 | args = append(args, "--reduceOpsTaskSplitting", "true") |
| 434 | } |
| 435 | |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 436 | // Test rendering to wrapped dsts on a few bots |
| 437 | // Also test "glenarrow", which hits F16 surfaces and F16 vertex colors. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 438 | if b.extraConfig("BonusConfigs") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 439 | configs = []string{"glbetex", "glbert", "glenarrow"} |
| 440 | } |
| 441 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 442 | if b.os("ChromeOS") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 443 | // Just run GLES for now - maybe add gles_msaa4 in the future |
| 444 | configs = []string{"gles"} |
| 445 | } |
| 446 | |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 447 | // Test GPU tessellation path renderer. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 448 | if b.extraConfig("GpuTess") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 449 | configs = []string{glPrefix + "msaa4"} |
Chris Dalton | 15f5184 | 2020-12-15 19:55:10 -0700 | [diff] [blame] | 450 | args = append(args, "--hwtess", "--pr", "tess") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 451 | } |
| 452 | |
Chris Dalton | 8151337 | 2021-03-18 00:32:48 -0600 | [diff] [blame] | 453 | // Test dynamic MSAA. |
| 454 | if b.extraConfig("DMSAA") { |
| 455 | configs = []string{glPrefix + "dmsaa"} |
| 456 | args = append(args, "--hwtess") |
| 457 | } |
| 458 | |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 459 | // DDL is a GPU-only feature |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 460 | if b.extraConfig("DDL1") { |
Robert Phillips | 2329db1 | 2020-05-04 09:20:00 -0400 | [diff] [blame] | 461 | // This bot generates comparison images for the large skps and the gms |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 462 | configs = filter(configs, "gl", "vk", "mtl") |
| 463 | args = append(args, "--skpViewportSize", "2048") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 464 | } |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 465 | if b.extraConfig("DDL3") { |
Robert Phillips | 2329db1 | 2020-05-04 09:20:00 -0400 | [diff] [blame] | 466 | // This bot generates the real ddl images for the large skps and the gms |
Robert Phillips | b323836 | 2021-02-26 08:48:20 -0500 | [diff] [blame] | 467 | configs = suffix(filter(configs, "gl", "vk", "mtl"), "ddl") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 468 | args = append(args, "--skpViewportSize", "2048") |
| 469 | args = append(args, "--gpuThreads", "0") |
| 470 | } |
Robert Phillips | fe7794d | 2020-06-26 09:36:22 -0400 | [diff] [blame] | 471 | if b.extraConfig("OOPRDDL") { |
| 472 | // This bot generates the real oopr/DDL images for the large skps and the GMs |
| 473 | configs = suffix(filter(configs, "gl", "vk", "mtl"), "ooprddl") |
| 474 | args = append(args, "--skpViewportSize", "2048") |
| 475 | args = append(args, "--gpuThreads", "0") |
| 476 | } |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 477 | } |
| 478 | |
| 479 | // Sharding. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 480 | tf := b.parts["test_filter"] |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 481 | if tf != "" && tf != "All" { |
| 482 | // Expected format: shard_XX_YY |
| 483 | split := strings.Split(tf, "_") |
| 484 | if len(split) == 3 { |
| 485 | args = append(args, "--shard", split[1]) |
| 486 | args = append(args, "--shards", split[2]) |
| 487 | } else { |
| 488 | glog.Fatalf("Invalid task name - bad shards: %s", tf) |
| 489 | } |
| 490 | } |
| 491 | |
| 492 | args = append(args, "--config") |
| 493 | args = append(args, configs...) |
| 494 | |
| 495 | removeFromArgs := func(arg string) { |
| 496 | args = remove(args, arg) |
| 497 | } |
| 498 | |
| 499 | // Run tests, gms, and image decoding tests everywhere. |
| 500 | args = append(args, "--src", "tests", "gm", "image", "lottie", "colorImage", "svg", "skp") |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 501 | if b.gpu() { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 502 | // Don't run the "svgparse_*" svgs on GPU. |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 503 | skip("_ svg _ svgparse_") |
Weston Tracey | 2462788 | 2020-04-06 21:27:14 -0400 | [diff] [blame] | 504 | } else if b.Name == "Test-Debian10-Clang-GCE-CPU-AVX2-x86_64-Debug-All-ASAN" { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 505 | // Only run the CPU SVGs on 8888. |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 506 | skip("~8888 svg _ _") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 507 | } else { |
| 508 | // On CPU SVGs we only care about parsing. Only run them on the above bot. |
| 509 | removeFromArgs("svg") |
| 510 | } |
| 511 | |
| 512 | // 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] | 513 | if b.extraConfig("SK_FORCE_RASTER_PIPELINE_BLITTER") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 514 | removeFromArgs("tests") |
| 515 | } |
| 516 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 517 | if b.extraConfig("NativeFonts") { // images won't exercise native font integration :) |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 518 | removeFromArgs("image") |
| 519 | removeFromArgs("colorImage") |
| 520 | } |
| 521 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 522 | if b.matchExtraConfig("DDL", "PDF") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 523 | // The DDL and PDF bots just render the large skps and the gms |
| 524 | removeFromArgs("tests") |
| 525 | removeFromArgs("image") |
| 526 | removeFromArgs("colorImage") |
| 527 | removeFromArgs("svg") |
| 528 | } else { |
| 529 | // No other bots render the .skps. |
| 530 | removeFromArgs("skp") |
| 531 | } |
| 532 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 533 | if b.extraConfig("Lottie") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 534 | // Only run the lotties on Lottie bots. |
| 535 | removeFromArgs("tests") |
| 536 | removeFromArgs("gm") |
| 537 | removeFromArgs("image") |
| 538 | removeFromArgs("colorImage") |
| 539 | removeFromArgs("svg") |
| 540 | removeFromArgs("skp") |
| 541 | } else { |
| 542 | removeFromArgs("lottie") |
| 543 | } |
| 544 | |
Tyler Denniston | 5f90ee0 | 2020-10-16 16:24:43 -0400 | [diff] [blame] | 545 | if b.extraConfig("TSAN") { |
| 546 | // skbug.com/10848 |
| 547 | removeFromArgs("svg") |
| 548 | } |
| 549 | |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 550 | // TODO: ??? |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 551 | skip("f16 _ _ dstreadshuffle") |
| 552 | skip("glsrgb image _ _") |
| 553 | skip("glessrgb image _ _") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 554 | |
| 555 | // --src image --config g8 means "decode into Gray8", which isn't supported. |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 556 | skip("g8 image _ _") |
| 557 | skip("g8 colorImage _ _") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 558 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 559 | if b.extraConfig("Valgrind") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 560 | // These take 18+ hours to run. |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 561 | skip("pdf gm _ fontmgr_iter") |
| 562 | skip("pdf _ _ PANO_20121023_214540.jpg") |
| 563 | skip("pdf skp _ worldjournal") |
| 564 | skip("pdf skp _ desk_baidu.skp") |
| 565 | skip("pdf skp _ desk_wikipedia.skp") |
| 566 | skip("_ svg _ _") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 567 | // skbug.com/9171 and 8847 |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 568 | skip("_ test _ InitialTextureClear") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 569 | } |
| 570 | |
Robert Phillips | 5890fec | 2020-07-28 15:23:42 -0400 | [diff] [blame] | 571 | if b.model("Pixel3") { |
| 572 | // skbug.com/10546 |
| 573 | skip("vkddl gm _ compressed_textures_nmof") |
| 574 | skip("vkddl gm _ compressed_textures_npot") |
| 575 | skip("vkddl gm _ compressed_textures") |
| 576 | } |
| 577 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 578 | if b.model("TecnoSpark3Pro") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 579 | // skbug.com/9421 |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 580 | skip("_ test _ InitialTextureClear") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 581 | } |
| 582 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 583 | if b.os("iOS") { |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 584 | skip(glPrefix + " skp _ _") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 585 | } |
| 586 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 587 | if b.matchOs("Mac", "iOS") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 588 | // CG fails on questionable bmps |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 589 | skip("_ image gen_platf rgba32abf.bmp") |
| 590 | skip("_ image gen_platf rgb24prof.bmp") |
| 591 | skip("_ image gen_platf rgb24lprof.bmp") |
| 592 | skip("_ image gen_platf 8bpp-pixeldata-cropped.bmp") |
| 593 | skip("_ image gen_platf 4bpp-pixeldata-cropped.bmp") |
| 594 | skip("_ image gen_platf 32bpp-pixeldata-cropped.bmp") |
| 595 | skip("_ image gen_platf 24bpp-pixeldata-cropped.bmp") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 596 | |
| 597 | // CG has unpredictable behavior on this questionable gif |
| 598 | // It's probably using uninitialized memory |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 599 | skip("_ image gen_platf frame_larger_than_image.gif") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 600 | |
| 601 | // CG has unpredictable behavior on incomplete pngs |
| 602 | // skbug.com/5774 |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 603 | skip("_ image gen_platf inc0.png") |
| 604 | skip("_ image gen_platf inc1.png") |
| 605 | skip("_ image gen_platf inc2.png") |
| 606 | skip("_ image gen_platf inc3.png") |
| 607 | skip("_ image gen_platf inc4.png") |
| 608 | skip("_ image gen_platf inc5.png") |
| 609 | skip("_ image gen_platf inc6.png") |
| 610 | skip("_ image gen_platf inc7.png") |
| 611 | skip("_ image gen_platf inc8.png") |
| 612 | skip("_ image gen_platf inc9.png") |
| 613 | skip("_ image gen_platf inc10.png") |
| 614 | skip("_ image gen_platf inc11.png") |
| 615 | skip("_ image gen_platf inc12.png") |
| 616 | skip("_ image gen_platf inc13.png") |
| 617 | skip("_ image gen_platf inc14.png") |
| 618 | skip("_ image gen_platf incInterlaced.png") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 619 | |
| 620 | // These images fail after Mac 10.13.1 upgrade. |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 621 | skip("_ image gen_platf incInterlaced.gif") |
| 622 | skip("_ image gen_platf inc1.gif") |
| 623 | skip("_ image gen_platf inc0.gif") |
| 624 | skip("_ image gen_platf butterfly.gif") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 625 | } |
| 626 | |
| 627 | // WIC fails on questionable bmps |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 628 | if b.matchOs("Win") { |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 629 | skip("_ image gen_platf pal8os2v2.bmp") |
| 630 | skip("_ image gen_platf pal8os2v2-16.bmp") |
| 631 | skip("_ image gen_platf rgba32abf.bmp") |
| 632 | skip("_ image gen_platf rgb24prof.bmp") |
| 633 | skip("_ image gen_platf rgb24lprof.bmp") |
| 634 | skip("_ image gen_platf 8bpp-pixeldata-cropped.bmp") |
| 635 | skip("_ image gen_platf 4bpp-pixeldata-cropped.bmp") |
| 636 | skip("_ image gen_platf 32bpp-pixeldata-cropped.bmp") |
| 637 | skip("_ image gen_platf 24bpp-pixeldata-cropped.bmp") |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 638 | if b.arch("x86_64") && b.cpu() { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 639 | // This GM triggers a SkSmallAllocator assert. |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 640 | skip("_ gm _ composeshader_bitmap") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 641 | } |
| 642 | } |
| 643 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 644 | if b.matchOs("Win", "Mac") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 645 | // WIC and CG fail on arithmetic jpegs |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 646 | skip("_ image gen_platf testimgari.jpg") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 647 | // More questionable bmps that fail on Mac, too. skbug.com/6984 |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 648 | skip("_ image gen_platf rle8-height-negative.bmp") |
| 649 | skip("_ image gen_platf rle4-height-negative.bmp") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 650 | } |
| 651 | |
| 652 | // These PNGs have CRC errors. The platform generators seem to draw |
| 653 | // uninitialized memory without reporting an error, so skip them to |
| 654 | // avoid lots of images on Gold. |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 655 | skip("_ image gen_platf error") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 656 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 657 | if b.os("Android", "iOS") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 658 | // This test crashes the N9 (perhaps because of large malloc/frees). It also |
| 659 | // is fairly slow and not platform-specific. So we just disable it on all of |
| 660 | // Android and iOS. skia:5438 |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 661 | skip("_ test _ GrStyledShape") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 662 | } |
| 663 | |
| 664 | if internalHardwareLabel == "5" { |
| 665 | // http://b/118312149#comment9 |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 666 | skip("_ test _ SRGBReadWritePixels") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 667 | } |
| 668 | |
| 669 | // skia:4095 |
| 670 | badSerializeGMs := []string{ |
John Stiles | 2cc126f | 2020-08-10 14:26:29 -0400 | [diff] [blame] | 671 | "strict_constraint_batch_no_red_allowed", // https://crbug.com/skia/10278 |
| 672 | "strict_constraint_no_red_allowed", // https://crbug.com/skia/10278 |
| 673 | "fast_constraint_red_is_allowed", // https://crbug.com/skia/10278 |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 674 | "c_gms", |
| 675 | "colortype", |
| 676 | "colortype_xfermodes", |
| 677 | "drawfilter", |
| 678 | "fontmgr_bounds_0.75_0", |
| 679 | "fontmgr_bounds_1_-0.25", |
| 680 | "fontmgr_bounds", |
| 681 | "fontmgr_match", |
| 682 | "fontmgr_iter", |
| 683 | "imagemasksubset", |
| 684 | "wacky_yuv_formats_domain", |
| 685 | "imagemakewithfilter", |
| 686 | "imagemakewithfilter_crop", |
| 687 | "imagemakewithfilter_crop_ref", |
| 688 | "imagemakewithfilter_ref", |
| 689 | } |
| 690 | |
| 691 | // skia:5589 |
| 692 | badSerializeGMs = append(badSerializeGMs, |
| 693 | "bitmapfilters", |
| 694 | "bitmapshaders", |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 695 | "convex_poly_clip", |
| 696 | "extractalpha", |
| 697 | "filterbitmap_checkerboard_32_32_g8", |
| 698 | "filterbitmap_image_mandrill_64", |
| 699 | "shadows", |
| 700 | "simpleaaclip_aaclip", |
| 701 | ) |
| 702 | |
| 703 | // skia:5595 |
| 704 | badSerializeGMs = append(badSerializeGMs, |
| 705 | "composeshader_bitmap", |
| 706 | "scaled_tilemodes_npot", |
| 707 | "scaled_tilemodes", |
| 708 | ) |
| 709 | |
| 710 | // skia:5778 |
| 711 | badSerializeGMs = append(badSerializeGMs, "typefacerendering_pfaMac") |
| 712 | // skia:5942 |
| 713 | badSerializeGMs = append(badSerializeGMs, "parsedpaths") |
| 714 | |
| 715 | // these use a custom image generator which doesn't serialize |
| 716 | badSerializeGMs = append(badSerializeGMs, "ImageGeneratorExternal_rect") |
| 717 | badSerializeGMs = append(badSerializeGMs, "ImageGeneratorExternal_shader") |
| 718 | |
| 719 | // skia:6189 |
| 720 | badSerializeGMs = append(badSerializeGMs, "shadow_utils") |
| 721 | |
| 722 | // skia:7938 |
| 723 | badSerializeGMs = append(badSerializeGMs, "persp_images") |
| 724 | |
| 725 | // Not expected to round trip encoding/decoding. |
| 726 | badSerializeGMs = append(badSerializeGMs, "all_bitmap_configs") |
| 727 | badSerializeGMs = append(badSerializeGMs, "makecolorspace") |
| 728 | badSerializeGMs = append(badSerializeGMs, "readpixels") |
| 729 | badSerializeGMs = append(badSerializeGMs, "draw_image_set_rect_to_rect") |
Michael Ludwig | 1c66ad9 | 2020-07-10 08:59:44 -0400 | [diff] [blame] | 730 | badSerializeGMs = append(badSerializeGMs, "draw_image_set_alpha_only") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 731 | badSerializeGMs = append(badSerializeGMs, "compositor_quads_shader") |
| 732 | badSerializeGMs = append(badSerializeGMs, "wacky_yuv_formats_qtr") |
Brian Salomon | 04aef10 | 2021-01-23 11:41:54 -0500 | [diff] [blame] | 733 | badSerializeGMs = append(badSerializeGMs, "runtime_effect_image") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 734 | |
| 735 | // This GM forces a path to be convex. That property doesn't survive |
| 736 | // serialization. |
| 737 | badSerializeGMs = append(badSerializeGMs, "analytic_antialias_convex") |
| 738 | |
| 739 | for _, test := range badSerializeGMs { |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 740 | skip("serialize-8888", "gm", "_", test) |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 741 | } |
| 742 | |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 743 | // It looks like we skip these only for out-of-memory concerns. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 744 | if b.matchOs("Win", "Android") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 745 | for _, test := range []string{"verylargebitmap", "verylarge_picture_image"} { |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 746 | skip("serialize-8888", "gm", "_", test) |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 747 | } |
| 748 | } |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 749 | if b.matchOs("Mac") && b.cpu() { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 750 | // skia:6992 |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 751 | skip("pic-8888", "gm", "_", "encode-platform") |
| 752 | skip("serialize-8888", "gm", "_", "encode-platform") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 753 | } |
| 754 | |
| 755 | // skia:4769 |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 756 | skip("pic-8888", "gm", "_", "drawfilter") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 757 | |
| 758 | // skia:4703 |
| 759 | for _, test := range []string{"image-cacherator-from-picture", |
| 760 | "image-cacherator-from-raster", |
| 761 | "image-cacherator-from-ctable"} { |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 762 | skip("pic-8888", "gm", "_", test) |
| 763 | skip("serialize-8888", "gm", "_", test) |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 764 | } |
| 765 | |
| 766 | // GM that requires raster-backed canvas |
| 767 | for _, test := range []string{"complexclip4_bw", "complexclip4_aa", "p3", |
| 768 | "async_rescale_and_read_text_up_large", |
| 769 | "async_rescale_and_read_text_up", |
| 770 | "async_rescale_and_read_text_down", |
| 771 | "async_rescale_and_read_dog_up", |
| 772 | "async_rescale_and_read_dog_down", |
| 773 | "async_rescale_and_read_rose", |
Brian Salomon | bacbb92 | 2021-01-21 19:48:00 -0500 | [diff] [blame] | 774 | "async_rescale_and_read_no_bleed", |
John Stiles | a0e407d | 2021-02-10 12:21:51 -0500 | [diff] [blame] | 775 | "async_rescale_and_read_alpha_type"} { |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 776 | skip("pic-8888", "gm", "_", test) |
| 777 | skip("serialize-8888", "gm", "_", test) |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 778 | |
| 779 | // GM requires canvas->makeSurface() to return a valid surface. |
| 780 | // TODO(borenet): These should be just outside of this block but are |
| 781 | // left here to match the recipe which has an indentation bug. |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 782 | skip("pic-8888", "gm", "_", "blurrect_compare") |
| 783 | skip("serialize-8888", "gm", "_", "blurrect_compare") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 784 | } |
| 785 | |
| 786 | // Extensions for RAW images |
| 787 | r := []string{ |
| 788 | "arw", "cr2", "dng", "nef", "nrw", "orf", "raf", "rw2", "pef", "srw", |
| 789 | "ARW", "CR2", "DNG", "NEF", "NRW", "ORF", "RAF", "RW2", "PEF", "SRW", |
| 790 | } |
| 791 | |
| 792 | // skbug.com/4888 |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 793 | // Skip RAW images (and a few large PNGs) on GPU bots |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 794 | // until we can resolve failures. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 795 | if b.gpu() { |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 796 | skip("_ image _ interlaced1.png") |
| 797 | skip("_ image _ interlaced2.png") |
| 798 | skip("_ image _ interlaced3.png") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 799 | for _, rawExt := range r { |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 800 | skip(fmt.Sprintf("_ image _ .%s", rawExt)) |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 801 | } |
| 802 | } |
| 803 | |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 804 | // Skip memory intensive tests on 32-bit bots. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 805 | if b.os("Win8") && b.arch("x86") { |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 806 | skip("_ image f16 _") |
| 807 | skip("_ image _ abnormal.wbmp") |
| 808 | skip("_ image _ interlaced1.png") |
| 809 | skip("_ image _ interlaced2.png") |
| 810 | skip("_ image _ interlaced3.png") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 811 | for _, rawExt := range r { |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 812 | skip(fmt.Sprintf("_ image _ .%s", rawExt)) |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 813 | } |
| 814 | } |
| 815 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 816 | if b.model("Nexus5", "Nexus5x") && b.gpu() { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 817 | // skia:5876 |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 818 | skip("_", "gm", "_", "encode-platform") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 819 | } |
| 820 | |
Brian Osman | 3b2fac6 | 2020-12-30 16:18:34 -0500 | [diff] [blame] | 821 | if b.model("AndroidOne") && b.gpu() { // skia:4697, skia:4704, skia:4694, skia:4705, skia:11133 |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 822 | skip("_", "gm", "_", "bigblurs") |
| 823 | skip("_", "gm", "_", "strict_constraint_no_red_allowed") |
| 824 | skip("_", "gm", "_", "fast_constraint_red_is_allowed") |
| 825 | skip("_", "gm", "_", "dropshadowimagefilter") |
| 826 | skip("_", "gm", "_", "filterfastbounds") |
| 827 | skip(glPrefix, "gm", "_", "imageblurtiled") |
| 828 | skip("_", "gm", "_", "imagefiltersclipped") |
| 829 | skip("_", "gm", "_", "imagefiltersscaled") |
| 830 | skip("_", "gm", "_", "imageresizetiled") |
| 831 | skip("_", "gm", "_", "matrixconvolution") |
| 832 | skip("_", "gm", "_", "strokedlines") |
Brian Osman | 3b2fac6 | 2020-12-30 16:18:34 -0500 | [diff] [blame] | 833 | skip("_", "gm", "_", "runtime_intrinsics_matrix") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 834 | if sampleCount > 0 { |
| 835 | glMsaaConfig := fmt.Sprintf("%smsaa%d", glPrefix, sampleCount) |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 836 | skip(glMsaaConfig, "gm", "_", "imageblurtiled") |
| 837 | skip(glMsaaConfig, "gm", "_", "imagefiltersbase") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 838 | } |
| 839 | } |
| 840 | |
John Stiles | a0e407d | 2021-02-10 12:21:51 -0500 | [diff] [blame] | 841 | if b.matchGpu("Adreno[56][0-9][0-9]") { // skia:11308 - disable on Adreno 5xx/6xx |
| 842 | skip("_", "tests", "_", "SkSLMatrixEquality_GPU") |
| 843 | } |
| 844 | |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 845 | match := []string{} |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 846 | if b.extraConfig("Valgrind") { // skia:3021 |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 847 | match = append(match, "~Threaded") |
| 848 | } |
| 849 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 850 | if b.extraConfig("Valgrind") && b.extraConfig("PreAbandonGpuContext") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 851 | // skia:6575 |
| 852 | match = append(match, "~multipicturedraw_") |
| 853 | } |
| 854 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 855 | if b.model("AndroidOne") { |
John Stiles | 2cc126f | 2020-08-10 14:26:29 -0400 | [diff] [blame] | 856 | match = append(match, "~WritePixels") // skia:4711 |
| 857 | match = append(match, "~PremulAlphaRoundTrip_Gpu") // skia:7501 |
| 858 | match = append(match, "~ReimportImageTextureWithMipLevels") // skia:8090 |
Brian Salomon | 602b402 | 2020-06-15 09:53:34 -0400 | [diff] [blame] | 859 | match = append(match, "~MorphologyFilterRadiusWithMirrorCTM_Gpu") // skia:10383 |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 860 | } |
| 861 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 862 | if b.model("GalaxyS6") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 863 | match = append(match, "~SpecialImage") // skia:6338 |
| 864 | match = append(match, "~skbug6653") // skia:6653 |
| 865 | } |
| 866 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 867 | if b.extraConfig("MSAN") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 868 | match = append(match, "~Once", "~Shared") // Not sure what's up with these tests. |
| 869 | } |
| 870 | |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 871 | // By default, we test with GPU threading enabled, unless specifically |
| 872 | // disabled. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 873 | if b.extraConfig("NoGPUThreads") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 874 | args = append(args, "--gpuThreads", "0") |
| 875 | } |
| 876 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 877 | if b.extraConfig("Vulkan") && b.gpu("Adreno530") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 878 | // skia:5777 |
| 879 | match = append(match, "~CopySurface") |
| 880 | } |
| 881 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 882 | if b.extraConfig("Vulkan") && b.matchGpu("Adreno") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 883 | // skia:7663 |
| 884 | match = append(match, "~WritePixelsNonTextureMSAA_Gpu") |
| 885 | match = append(match, "~WritePixelsMSAA_Gpu") |
| 886 | } |
| 887 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 888 | if b.extraConfig("Vulkan") && b.isLinux() && b.gpu("IntelIris640") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 889 | match = append(match, "~VkHeapTests") // skia:6245 |
| 890 | } |
| 891 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 892 | if b.isLinux() && b.gpu("IntelIris640") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 893 | match = append(match, "~Programs") // skia:7849 |
| 894 | } |
| 895 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 896 | if b.model("TecnoSpark3Pro") { |
Brian Osman | b883f7d | 2020-03-26 16:55:07 -0400 | [diff] [blame] | 897 | // skia:9814 |
| 898 | match = append(match, "~Programs") |
| 899 | match = append(match, "~ProcessorCloneTest") |
| 900 | match = append(match, "~ProcessorOptimizationValidationTest") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 901 | } |
| 902 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 903 | if b.gpu("IntelIris640", "IntelHD615", "IntelHDGraphics615") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 904 | match = append(match, "~^SRGBReadWritePixels$") // skia:9225 |
| 905 | } |
| 906 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 907 | if b.extraConfig("Vulkan") && b.isLinux() && b.gpu("IntelHD405") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 908 | // skia:7322 |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 909 | skip("vk", "gm", "_", "skbug_257") |
| 910 | skip("vk", "gm", "_", "filltypespersp") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 911 | match = append(match, "~^ClearOp$") |
| 912 | match = append(match, "~^CopySurface$") |
| 913 | match = append(match, "~^ImageNewShader_GPU$") |
| 914 | match = append(match, "~^InitialTextureClear$") |
| 915 | match = append(match, "~^PinnedImageTest$") |
| 916 | match = append(match, "~^ReadPixels_Gpu$") |
| 917 | match = append(match, "~^ReadPixels_Texture$") |
| 918 | match = append(match, "~^SRGBReadWritePixels$") |
| 919 | match = append(match, "~^VkUploadPixelsTests$") |
| 920 | match = append(match, "~^WritePixelsNonTexture_Gpu$") |
| 921 | match = append(match, "~^WritePixelsNonTextureMSAA_Gpu$") |
| 922 | match = append(match, "~^WritePixels_Gpu$") |
| 923 | match = append(match, "~^WritePixelsMSAA_Gpu$") |
| 924 | } |
| 925 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 926 | if b.extraConfig("Vulkan") && b.gpu("GTX660") && b.matchOs("Win") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 927 | // skbug.com/8047 |
| 928 | match = append(match, "~FloatingPointTextureTest$") |
| 929 | } |
| 930 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 931 | if b.extraConfig("Metal") && b.gpu("RadeonHD8870M") && b.matchOs("Mac") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 932 | // skia:9255 |
| 933 | match = append(match, "~WritePixelsNonTextureMSAA_Gpu") |
Weston Tracey | a77620b | 2021-02-25 11:24:34 -0500 | [diff] [blame] | 934 | // skbug.com/11366 |
| 935 | match = append(match, "~SurfacePartialDraw_Gpu") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 936 | } |
| 937 | |
Brian Salomon | 63a0a75 | 2020-06-26 13:32:09 -0400 | [diff] [blame] | 938 | if b.extraConfig("Direct3D") { |
Jim Van Verth | 2b98f16 | 2020-06-11 15:27:35 -0400 | [diff] [blame] | 939 | // skia:9935 |
Jim Van Verth | 2b98f16 | 2020-06-11 15:27:35 -0400 | [diff] [blame] | 940 | match = append(match, "~^DDLSkSurfaceFlush$") |
Jim Van Verth | 2b98f16 | 2020-06-11 15:27:35 -0400 | [diff] [blame] | 941 | match = append(match, "~^GrBackendTextureImageMipMappedTest$") |
Jim Van Verth | 2b98f16 | 2020-06-11 15:27:35 -0400 | [diff] [blame] | 942 | match = append(match, "~^GrTextureMipMapInvalidationTest$") |
Jim Van Verth | 2b98f16 | 2020-06-11 15:27:35 -0400 | [diff] [blame] | 943 | match = append(match, "~^SkImage_makeTextureImage$") |
Jim Van Verth | 2b98f16 | 2020-06-11 15:27:35 -0400 | [diff] [blame] | 944 | match = append(match, "~^TextureIdleStateTest$") |
Jim Van Verth | 2b98f16 | 2020-06-11 15:27:35 -0400 | [diff] [blame] | 945 | } |
| 946 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 947 | if b.extraConfig("ANGLE") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 948 | // skia:7835 |
| 949 | match = append(match, "~BlurMaskBiggerThanDest") |
| 950 | } |
| 951 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 952 | if b.gpu("IntelIris6100") && b.extraConfig("ANGLE") && !b.debug() { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 953 | // skia:7376 |
| 954 | match = append(match, "~^ProcessorOptimizationValidationTest$") |
| 955 | } |
| 956 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 957 | if b.gpu("IntelIris6100", "IntelHD4400") && b.extraConfig("ANGLE") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 958 | // skia:6857 |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 959 | skip("angle_d3d9_es2", "gm", "_", "lighting") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 960 | } |
| 961 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 962 | if b.gpu("PowerVRGX6250") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 963 | match = append(match, "~gradients_view_perspective_nodither") //skia:6972 |
| 964 | } |
| 965 | |
Brian Salomon | 1d2a26d | 2021-03-30 10:59:10 -0400 | [diff] [blame] | 966 | if b.matchOs("iOS") && b.extraConfig("Metal") { |
| 967 | match = append(match, "~^SurfaceContextWritePixels$") //skia:11130 |
| 968 | } |
| 969 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 970 | if b.arch("arm") && b.extraConfig("ASAN") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 971 | // TODO: can we run with env allocator_may_return_null=1 instead? |
| 972 | match = append(match, "~BadImage") |
| 973 | } |
| 974 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 975 | if b.matchOs("Mac") && b.gpu("IntelHD6000") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 976 | // skia:7574 |
| 977 | match = append(match, "~^ProcessorCloneTest$") |
| 978 | match = append(match, "~^GrMeshTest$") |
| 979 | } |
| 980 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 981 | if b.matchOs("Mac") && b.gpu("IntelHD615") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 982 | // skia:7603 |
| 983 | match = append(match, "~^GrMeshTest$") |
| 984 | } |
| 985 | |
Greg Daniel | dbe7770 | 2020-05-13 18:36:34 -0400 | [diff] [blame] | 986 | if b.extraConfig("Vulkan") && b.model("GalaxyS20") { |
| 987 | // skia:10247 |
| 988 | match = append(match, "~VkPrepareForExternalIOQueueTransitionTest") |
| 989 | } |
| 990 | |
Mike Klein | a54d380 | 2020-07-24 12:37:32 -0500 | [diff] [blame] | 991 | if len(skipped) > 0 { |
| 992 | args = append(args, "--skip") |
| 993 | args = append(args, skipped...) |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 994 | } |
| 995 | |
| 996 | if len(match) > 0 { |
| 997 | args = append(args, "--match") |
| 998 | args = append(args, match...) |
| 999 | } |
| 1000 | |
| 1001 | // These bots run out of memory running RAW codec tests. Do not run them in |
| 1002 | // parallel |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 1003 | // TODO(borenet): Previously this was `'Nexus5' in bot or 'Nexus9' in bot` |
| 1004 | // which also matched 'Nexus5x'. I added That here to maintain the |
| 1005 | // existing behavior, but we should verify that it's needed. |
| 1006 | if b.model("Nexus5", "Nexus5x", "Nexus9") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 1007 | args = append(args, "--noRAW_threading") |
| 1008 | } |
| 1009 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 1010 | if b.extraConfig("FSAA") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 1011 | args = append(args, "--analyticAA", "false") |
| 1012 | } |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 1013 | if b.extraConfig("FAAA") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 1014 | args = append(args, "--forceAnalyticAA") |
| 1015 | } |
| 1016 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 1017 | if !b.extraConfig("NativeFonts") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 1018 | args = append(args, "--nonativeFonts") |
| 1019 | } |
| 1020 | |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 1021 | if b.extraConfig("GDI") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 1022 | args = append(args, "--gdi") |
| 1023 | } |
| 1024 | |
| 1025 | // Let's make all bots produce verbose output by default. |
| 1026 | args = append(args, "--verbose") |
| 1027 | |
| 1028 | // See skia:2789. |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 1029 | if b.extraConfig("AbandonGpuContext") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 1030 | args = append(args, "--abandonGpuContext") |
| 1031 | } |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 1032 | if b.extraConfig("PreAbandonGpuContext") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 1033 | args = append(args, "--preAbandonGpuContext") |
| 1034 | } |
Eric Boren | c27e702 | 2020-03-09 08:43:45 -0400 | [diff] [blame] | 1035 | if b.extraConfig("ReleaseAndAbandonGpuContext") { |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 1036 | args = append(args, "--releaseAndAbandonGpuContext") |
| 1037 | } |
Eric Boren | 457c1eb | 2020-03-16 13:49:33 -0400 | [diff] [blame] | 1038 | |
| 1039 | // Finalize the DM flags and properties. |
| 1040 | b.recipeProp("dm_flags", marshalJson(args)) |
| 1041 | b.recipeProp("dm_properties", marshalJson(properties)) |
Eric Boren | 59e7496 | 2020-03-23 09:17:24 -0400 | [diff] [blame] | 1042 | |
| 1043 | // Add properties indicating which assets the task should use. |
| 1044 | if b.matchExtraConfig("Lottie") { |
Eric Boren | 0f9d5bd | 2020-03-23 09:57:05 -0400 | [diff] [blame] | 1045 | b.asset("lottie-samples") |
Eric Boren | 59e7496 | 2020-03-23 09:17:24 -0400 | [diff] [blame] | 1046 | b.recipeProp("lotties", "true") |
| 1047 | } else { |
| 1048 | b.asset("skimage") |
| 1049 | b.recipeProp("images", "true") |
| 1050 | b.asset("skp") |
| 1051 | b.recipeProp("skps", "true") |
| 1052 | b.asset("svg") |
| 1053 | b.recipeProp("svgs", "true") |
| 1054 | } |
| 1055 | b.recipeProp("do_upload", fmt.Sprintf("%t", b.doUpload())) |
| 1056 | b.recipeProp("resources", "true") |
Eric Boren | a1613c9 | 2020-03-02 12:55:38 -0500 | [diff] [blame] | 1057 | } |