1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
content / test / gpu / gpu_tests / gpu_helper.py [blame]
# Copyright 2019 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import os
import re
from typing import Dict, FrozenSet, List, Match, Optional, Tuple, Union
import unittest.mock as mock
from gpu_tests import constants
from gpu_tests.util import host_information
from telemetry.internal.platform import gpu_info as tgi
# This set must be the union of the driver tags used in WebGL and WebGL2
# expectations files.
# Examples:
# intel_lt_25.20.100.6577
# mesa_ge_20.1
EXPECTATIONS_DRIVER_TAGS = frozenset([
'mesa_lt_19.1',
'mesa_ge_21.0',
'mesa_ge_23.2',
'nvidia_ge_31.0.15.4601',
'nvidia_lt_31.0.15.4601',
'nvidia_ge_535.183.01',
'nvidia_lt_535.183.01',
])
# Driver tag format: VENDOR_OPERATION_VERSION
DRIVER_TAG_MATCHER = re.compile(
r'^([a-z\d]+)_(eq|ne|ge|gt|le|lt)_([a-z\d\.]+)$')
REMOTE_BROWSER_TYPES = [
'android-chromium',
'android-webview-instrumentation',
'cros-chrome',
'fuchsia-chrome',
'web-engine-shell',
'cast-streaming-shell',
]
TAG_SUBSTRING_REPLACEMENTS = {
# nvidia on desktop, nvidia-coproration on Android.
'nvidia-corporation': 'nvidia',
}
ENTIRE_TAG_REPLACEMENTS = {
# Includes a Vulkan and LLVM version.
re.compile('google-vulkan.*swiftshader-device.*', re.IGNORECASE):
'google-vulkan',
}
INTEL_DEVICE_ID_MASK = 0xFF00
INTEL_GEN_9 = {0x1900, 0x3100, 0x3E00, 0x5900, 0x5A00, 0x9B00}
INTEL_GEN_12 = {0x4C00, 0x9A00, 0x4900, 0x4600, 0x4F00, 0x5600, 0xA700, 0x7D00}
def _ParseANGLEGpuVendorString(device_string: str) -> Optional[str]:
if not device_string:
return None
# ANGLE's device (renderer) string is of the form:
# "ANGLE (vendor_string, renderer_string, gl_version profile)"
# This function will be used to get the first value in the tuple
match = re.search(r'ANGLE \((.*), .*, .*\)', device_string)
if match:
return match.group(1)
return None
def GetANGLEGpuDeviceId(device_string: str) -> Optional[str]:
if not device_string:
return None
# ANGLE's device (renderer) string is of the form:
# "ANGLE (vendor_string, renderer_string, gl_version profile)"
# This function will be used to get the second value in the tuple
match = re.search(r'ANGLE \(.*, (.*), .*\)', device_string)
if match:
return match.group(1)
return None
def GetGpuVendorString(gpu_info: Optional[tgi.GPUInfo], index: int) -> str:
if gpu_info:
primary_gpu = gpu_info.devices[index]
if primary_gpu:
vendor_string = primary_gpu.vendor_string
angle_vendor_string = _ParseANGLEGpuVendorString(
primary_gpu.device_string)
vendor_id = primary_gpu.vendor_id
try:
vendor_id = constants.GpuVendor(vendor_id)
return vendor_id.name.lower()
except ValueError:
# Hit if vendor_id is not a known vendor.
pass
if angle_vendor_string:
return angle_vendor_string.lower()
if vendor_string:
return vendor_string.split(' ')[0].lower()
return 'unknown_gpu'
def GetGpuDeviceId(gpu_info: Optional[tgi.GPUInfo],
index: int) -> Union[int, str]:
if gpu_info:
primary_gpu = gpu_info.devices[index]
if primary_gpu:
return (primary_gpu.device_id
or GetANGLEGpuDeviceId(primary_gpu.device_string)
or primary_gpu.device_string)
return 0
def IsIntel(vendor_id: int) -> bool:
return vendor_id == constants.GpuVendor.INTEL
# Intel GPU architectures
def IsIntelGen9(gpu_device_id: int) -> bool:
return gpu_device_id & INTEL_DEVICE_ID_MASK in INTEL_GEN_9
def IsIntelGen12(gpu_device_id: int) -> bool:
return gpu_device_id & INTEL_DEVICE_ID_MASK in INTEL_GEN_12
def GetGpuDriverVendor(gpu_info: Optional[tgi.GPUInfo]) -> Optional[str]:
if gpu_info:
primary_gpu = gpu_info.devices[0]
if primary_gpu:
return primary_gpu.driver_vendor
return None
def GetGpuDriverVersion(gpu_info: Optional[tgi.GPUInfo]) -> Optional[str]:
if gpu_info:
primary_gpu = gpu_info.devices[0]
if primary_gpu:
return primary_gpu.driver_version
return None
def GetANGLERenderer(gpu_info: Optional[tgi.GPUInfo]) -> str:
retval = 'angle-disabled'
if gpu_info and gpu_info.aux_attributes:
gl_renderer = gpu_info.aux_attributes.get('gl_renderer')
if gl_renderer and 'ANGLE' in gl_renderer:
if 'Direct3D11' in gl_renderer:
retval = 'angle-d3d11'
elif 'Direct3D9' in gl_renderer:
retval = 'angle-d3d9'
elif 'OpenGL ES' in gl_renderer:
retval = 'angle-opengles'
elif 'OpenGL' in gl_renderer:
retval = 'angle-opengl'
elif 'Metal' in gl_renderer:
retval = 'angle-metal'
# SwiftShader first because it also contains Vulkan
elif 'SwiftShader' in gl_renderer:
retval = 'angle-swiftshader'
elif 'Vulkan' in gl_renderer:
retval = 'angle-vulkan'
return retval
def GetCommandDecoder(gpu_info: Optional[tgi.GPUInfo]) -> str:
if gpu_info and gpu_info.aux_attributes and \
gpu_info.aux_attributes.get('passthrough_cmd_decoder', False):
return 'passthrough'
return 'no_passthrough'
def GetSkiaGraphiteStatus(gpu_info: Optional[tgi.GPUInfo]) -> str:
if gpu_info and gpu_info.feature_status and gpu_info.feature_status.get(
'skia_graphite') == 'enabled_on':
return 'graphite-enabled'
return 'graphite-disabled'
def GetSkiaRenderer(gpu_info: Optional[tgi.GPUInfo]) -> str:
retval = 'renderer-software'
if gpu_info:
gpu_feature_status = gpu_info.feature_status
skia_renderer_enabled = (
gpu_feature_status
and gpu_feature_status.get('gpu_compositing') == 'enabled')
if skia_renderer_enabled:
if HasVulkanSkiaRenderer(gpu_feature_status):
retval = 'renderer-skia-vulkan'
# The check for GL must come after Vulkan since the 'opengl' feature can
# be enabled for WebGL and interop even if SkiaRenderer is using Vulkan.
elif HasGlSkiaRenderer(gpu_feature_status):
retval = 'renderer-skia-gl'
return retval
def GetDisplayServer(browser_type: str) -> Optional[str]:
# Browser types run on a remote device aren't Linux, but the host running
# this code uses Linux, so return early to avoid erroneously reporting a
# display server.
if browser_type in REMOTE_BROWSER_TYPES:
return None
if host_information.IsLinux():
if 'WAYLAND_DISPLAY' in os.environ:
return 'display-server-wayland'
return 'display-server-x'
return None
def GetOOPCanvasStatus(gpu_info: Optional[tgi.GPUInfo]) -> str:
if gpu_info and gpu_info.feature_status and gpu_info.feature_status.get(
'canvas_oop_rasterization') == 'enabled_on':
return 'oop-c'
return 'no-oop-c'
def GetAsanStatus(gpu_info: Optional[tgi.GPUInfo]) -> str:
if gpu_info and gpu_info.aux_attributes.get('is_asan', False):
return 'asan'
return 'no-asan'
def GetTargetCpuStatus(gpu_info: Optional[tgi.GPUInfo]) -> str:
suffix = 'unknown'
if gpu_info:
suffix = gpu_info.aux_attributes.get('target_cpu_bits', 'unknown')
return 'target-cpu-%s' % suffix
def GetClangCoverage(gpu_info: Optional[tgi.GPUInfo]) -> str:
if gpu_info and gpu_info.aux_attributes.get('is_clang_coverage', False):
return 'clang-coverage'
return 'no-clang-coverage'
def HasGlSkiaRenderer(gpu_feature_status: Dict[str, str]) -> bool:
return (bool(gpu_feature_status)
and gpu_feature_status.get('opengl') == 'enabled_on')
def HasVulkanSkiaRenderer(gpu_feature_status: Dict[str, str]) -> bool:
return (bool(gpu_feature_status)
and gpu_feature_status.get('vulkan') == 'enabled_on')
def ReplaceTags(tags: List[str]) -> List[str]:
"""Replaces certain strings in tags to make them consistent across platforms.
Args:
tags: A list of strings containing expectation tags.
Returns:
|tags| but potentially with some elements replaced.
"""
replaced_tags = []
for t in tags:
continue_to_next_tag = False
for regex, replacement in ENTIRE_TAG_REPLACEMENTS.items():
if regex.match(t):
replaced_tags.append(replacement)
continue_to_next_tag = True
break
if continue_to_next_tag:
continue
for original, replacement in TAG_SUBSTRING_REPLACEMENTS.items():
if original in t:
replaced_tags.append(t.replace(original, replacement))
continue_to_next_tag = True
break
if continue_to_next_tag:
continue
replaced_tags.append(t)
return replaced_tags
# used by unittests to create a mock arguments object
def GetMockArgs(webgl_version: str = '1.0.0') -> mock.MagicMock:
args = mock.MagicMock()
args.webgl_conformance_version = webgl_version
args.webgl2_only = False
# for power_measurement_integration_test.py, .url has to be None to
# generate the correct test lists for bots.
args.url = None
args.duration = 10
args.delay = 10
args.resolution = 100
args.fullscreen = False
args.underlay = False
args.logdir = '/tmp'
args.repeat = 1
args.outliers = 0
args.bypass_ipg = False
args.expected_vendor_id = 0
args.expected_device_id = 0
args.browser_options = []
args.use_worker = 'none'
return args
def MatchDriverTag(tag: str) -> Optional[Match[str]]:
return DRIVER_TAG_MATCHER.match(tag.lower())
# No good way to reduce the number of local variables, particularly since each
# argument is also considered a local. Also no good way to reduce the number of
# branches without harming readability.
# pylint: disable=too-many-locals,too-many-branches
def EvaluateVersionComparison(version: str,
operation: str,
ref_version: str,
os_name: Optional[str] = None,
driver_vendor: Optional[str] = None) -> bool:
def parse_version(ver: str) -> Union[Tuple[int, str], Tuple[None, None]]:
if ver.isdigit():
return int(ver), ''
for i, digit in enumerate(ver):
if not digit.isdigit():
return int(ver[:i]) if i > 0 else 0, ver[i:]
return None, None
def versions_can_be_compared(ver_list1, ver_list2):
# If either of the two versions doesn't match the Intel driver version
# schema, they should not be compared.
if len(ver_list1) != 4 or len(ver_list2) != 4:
return False
return True
ver_list1 = version.split('.')
ver_list2 = ref_version.split('.')
# On Windows, if the driver vendor is Intel, the driver version should be
# compared based on the Intel graphics driver version schema.
# https://www.intel.com/content/www/us/en/support/articles/000005654/graphics-drivers.html
if os_name == 'win' and driver_vendor == 'intel':
if not versions_can_be_compared(ver_list1, ver_list2):
return operation == 'ne'
ver_list1 = ver_list1[2:]
ver_list2 = ver_list2[2:]
for i in range(0, max(len(ver_list1), len(ver_list2))):
ver1 = ver_list1[i] if i < len(ver_list1) else '0'
ver2 = ver_list2[i] if i < len(ver_list2) else '0'
num1, suffix1 = parse_version(ver1)
num2, suffix2 = parse_version(ver2)
if num1 is None:
continue
# This comes from EXPECTATIONS_DRIVER_TAGS, so we should never fail to
# parse a version.
assert num2 is not None
if not num1 == num2:
diff = num1 - num2
elif suffix1 == suffix2:
continue
elif suffix1 > suffix2:
diff = 1
else:
diff = -1
if operation == 'eq':
return False
if operation == 'ne':
return True
if operation in ('ge', 'gt'):
return diff > 0
if operation in ('le', 'lt'):
return diff < 0
raise Exception('Invalid operation: ' + operation)
return operation in ('eq', 'ge', 'le')
# pylint: enable=too-many-locals,too-many-branches
# No good way to reduce the number of return statements to the required level
# without harming readability.
# pylint: disable=too-many-return-statements,too-many-branches
def IsDriverTagDuplicated(driver_tag1: str, driver_tag2: str) -> bool:
if driver_tag1 == driver_tag2:
return True
match = MatchDriverTag(driver_tag1)
assert match is not None
vendor1 = match.group(1)
operation1 = match.group(2)
version1 = match.group(3)
match = MatchDriverTag(driver_tag2)
assert match is not None
vendor2 = match.group(1)
operation2 = match.group(2)
version2 = match.group(3)
if vendor1 != vendor2:
return False
if operation1 == 'ne':
return not (operation2 == 'eq' and version1 == version2)
if operation2 == 'ne':
return not (operation1 == 'eq' and version1 == version2)
if operation1 == 'eq':
return EvaluateVersionComparison(version1, operation2, version2)
if operation2 == 'eq':
return EvaluateVersionComparison(version2, operation1, version1)
if operation1 in ('ge', 'gt') and operation2 in ('ge', 'gt'):
return True
if operation1 in ('le', 'lt') and operation2 in ('le', 'lt'):
return True
if operation1 == 'ge':
if operation2 == 'le':
return not EvaluateVersionComparison(version1, 'gt', version2)
if operation2 == 'lt':
return not EvaluateVersionComparison(version1, 'ge', version2)
if operation1 == 'gt':
return not EvaluateVersionComparison(version1, 'ge', version2)
if operation1 == 'le':
if operation2 == 'ge':
return not EvaluateVersionComparison(version1, 'lt', version2)
if operation2 == 'gt':
return not EvaluateVersionComparison(version1, 'le', version2)
if operation1 == 'lt':
return not EvaluateVersionComparison(version1, 'le', version2)
assert False
return False
# pylint: enable=too-many-return-statements,too-many-branches
def ExpectationsDriverTags() -> FrozenSet[str]:
return EXPECTATIONS_DRIVER_TAGS